Is String a primitive type?

I am curious about the string and primitive types. Article like this says string is primitive type. However second article on MSDN does not list string as primitive type.

However when I ran the code provided in second article, it displays String is not Primitive type.

Can any one guide me on this?

Both articles say that string is NOT a primitive type. Which it is not.

If you compile and run the example code from the second article it would print:

> string is not a primitive type.

I think the confusion about this is, that the syntax of of creating a new string is similar to creating value types.

When defining a value type all of these are equal (on a 32 bit system anyway)

System.Int32 a = new System.Int32(5);
System.Int32 a = 5;
int a = 5;

Just like these when creating a reference type string:

System.String s = new System.String(new char[]{'h', 'e', 'l', 'l', 'o'});
System.String s = "hello";
string s = "hello";

Also we can compare strings by value even though they are reference types:

s == "hello";//true

This still does not make string a primitive type.

The accepted answer to this question should give you details on that.

There is no "Microsoft" definition of what a primitive type is.

There are only definitions of primitive types in a given context.

• The CLR defines primitive types as being nothing more than:

  • System.Boolean
  • System.Byte
  • System.SByte
  • System.Int16
  • System.UInt16
  • System.Int32
  • System.UInt32
  • System.Int64
  • System.UInt64
  • System.IntPtr
  • System.UIntPtr
  • System.Char
  • System.Double
  • System.Single

• The VB.NET specification version 10 (in section 7.3) defines "primitive types" as being types that have a keyword alias for the type (thus allowing the usage of that type without importing the System namespace), a way to define instances of that type with a literal; and permitting the use of these types as constants; the primitive types in VB.NET are:

  • System.Byte
  • System.SByte
  • System.UInt16 (UShort)
  • System.Int16 (Short)
  • System.UInt32 (UInteger)
  • System.Int32 (Integer)
  • System.UInt64 (ULong)
  • System.Int64 (Long)
  • System.Single
  • System.Double
  • System.Decimal
  • System.Boolean
  • System.DateTime (Date)
  • System.Char
  • System.String

• The C# specification (version 4) defines keyword aliases for some types, and also defines way of specifying literals for some values; it also defines, separately, which types are available in constant expressions; the closest concept to "primitive types" that C# has is in section 4.1.4: Simple types. (the word "primitive" is only used twice in the 600 pages document); these primitive types are simply defined as "value types that have a keyword alias in C#" - string is not mentioned in that section:

  • System.SByte (sbyte)
  • System.Byte (byte)
  • System.Int16 (short)
  • System.UInt16 (ushort)
  • System.Int32 (int)
  • System.UInt32 (uint)
  • System.Int64 (long)
  • System.UInt64 (ulong)
  • System.Char (char)
  • System.Single (float)
  • System.Double (double)
  • System.Boolean (bool)
  • System.Decimal (decimal)

You will see that there is only a partial overlap between all of these things; the CLR sees both pointer types as primitive, both VB.NET and C# see decimal as a primitive/simple type, only VB.NET sees DateTime as anything special, both VB.NET and C# have a keyword alias and a literal syntax for strings but only VB.NET specifies String as being a "primitive type", while C# simply has a section of its specification dedicated to System.String...

In conclusion: different contexts have different definitions for what a "primitive type" is. It does not matter - just learn how to use your programming language, there is no sense in fighting and thinking over such polymorphic words. Personally, I wonder why the property Type.IsPrimitive even exists.

As for System.String:

• CLR: Nothing special, it is just a reference type;
• VB.NET: It is a primitive type;
• C#: String is its own very special snowflake;

Change-of-stance Update: No since code doesn't lie

Console.WriteLine(typeof(string).IsPrimitive); => False
Console.WriteLine(typeof(int).IsPrimitive); => True

-----end of update.
But some documentation online seems to treat String as a primitive. I think Yes - based on the following definition of "primitive". (My personal definition would be a type which can't be broken down further into component types. But I guess we're just being 'pedantic' here, it's a non-issue for me mostly.)

> all primitive data types in C# are > objects in the System namespace. For > each data type, a short name, or > alias, is provided.

Source: http://msdn.microsoft.com/en-us/library/ms228360%28VS.80%29.aspx Another article in favor - MSDN Mag article

Summary: I guess the answer depends on your definition of primitive, which is not unambiguously defined. Source: Eric Lippert on another SO thread.

.NET defines (from your article):

> The primitive types are Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Char, Double, and Single.

So no. Inbuilt and very important: yes, but not a primitive.

VB uses a slightly different definition to the CLI and C# it seems.

Under Microsoft's definition of "primitive", string is not considered a primitive type. On the other hand, Microsoft tends to use terminology without really formulating a clear or consistent definition (e.g. "unmanaged resource"), and one could usefully define "primitive" to include "String", "Array", and "Object", since in their absence there would be no way to define types that could emulate them efficiently.

No, the string is not a primitive type.

However, it has some characteristics common with the primitive types.

The language supports string literals in the code, so that you don't have to explicitly create String instances using the new keyword to get a string object.

There is also support for concatenating strings using the + operator, which the compiler turns into a call to the String.Concat method.

Strings are immutable, which means that it in most situations has value type semantics, just like the primitive types.

String is a special primitive type. It is not a value type, but can be considered a primitive type because it can be created by writing literals, eg/ "hello" and it is possible to declare a constant of type string. Having said that, the value of IsPrimitive returns false

Console.WriteLine("hello".GetType().IsPrimitive) // output = False

EDIT: I want to take back my answer here. It is technically not a primitive type, but shares the properties I stated above.

In c# the types are primarily defined as two types: value types and primitive types.

First see the definition of primitive types in C#.

> On the other hand, all primitive data > types in C# are objects in the System > namespace. For each data type, a short > name, or alias, is provided. For > instance, int is the short name for > System.Int32 and double is the short > form of System.Double.

Now, read this article for the difference: Primitive Types & Value Types

System.String maps to "string", which is a primitive type in the CLI. But in the reality, value types are the ones which go in the stack and not in the heap space.

So, the key is Value types vs Primitive types. By Microsoft's definition of primitive, it is a primitive type, but in a more general sense, its not.

String is a reference type. To verify this do F12 on string.

enter image description here

they are not, because they are sequence of characters