Is String a primitive type?

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.