What is the difference between String and string in C#? [Answered]

Sample query:

Example (note the case):

string s = "Hello world!";
String s = "Hello world!";

What are the guidelines for the use of each? And what are the differences?

What is the difference between String and string in C#? Answer #1:

string is an alias in C# for System.String.
So technically, there is no difference. It’s like int vs. System.Int32.

As far as guidelines, it’s generally recommended to use string any time you’re referring to an object.

e.g.

string place = "world";

Likewise, I think it’s generally recommended to use String if you need to refer specifically to the class.

e.g.

string greet = String.Format("Hello {0}!", place);

This is the style that Microsoft tends to use in their examples.

It appears that the guidance in this area may have changed, as StyleCop now enforces the use of the C# specific aliases.

Answer #2:

Just for the sake of completeness, here’s a brain dump of related information…

As others have noted, string is an alias for System.String. Assuming your code using String compiles to System.String (i.e. you haven’t got a using directive for some other namespace with a different String type), they compile to the same code, so at execution time there is no difference whatsoever. This is just one of the aliases in C#. The complete list is:

object:  System.Object
string:  System.String
bool:    System.Boolean
byte:    System.Byte
sbyte:   System.SByte
short:   System.Int16
ushort:  System.UInt16
int:     System.Int32
uint:    System.UInt32
long:    System.Int64
ulong:   System.UInt64
float:   System.Single
double:  System.Double
decimal: System.Decimal
char:    System.Char

Apart from string and object, the aliases are all to value types. decimal is a value type, but not a primitive type in the CLR. The only primitive type which doesn’t have an alias is System.IntPtr.

In the spec, the value type aliases are known as “simple types”. Literals can be used for constant values of every simple type; no other value types have literal forms available. (Compare this with VB, which allows DateTime literals, and has an alias for it too.)

There is one circumstance in which you have to use the aliases: when explicitly specifying an enum’s underlying type. For instance:

public enum Foo : UInt32 {} // Invalid
public enum Bar : uint   {} // Valid

That’s just a matter of the way the spec defines enum declarations – the part after the colon has to be the integral-type production, which is one token of sbytebyteshortushortintuintlongulongchar… as opposed to a type production as used by variable declarations for example. It doesn’t indicate any other difference.

Finally, when it comes to which to use: personally I use the aliases everywhere for the implementation, but the CLR type for any APIs. It really doesn’t matter too much which you use in terms of implementation – consistency among your team is nice, but no-one else is going to care. On the other hand, it’s genuinely important that if you refer to a type in an API, you do so in a language-neutral way. A method called ReadInt32 is unambiguous, whereas a method called ReadInt requires interpretation. The caller could be using a language that defines an int alias for Int16, for example. The .NET framework designers have followed this pattern, good examples being in the BitConverterBinaryReader and Convert classes.

Answer #3:

String stands for System.String and it is a .NET Framework type. string is an alias in the C# language for System.String. Both of them are compiled to System.String in IL (Intermediate Language), so there is no difference. Choose what you like and use that. If you code in C#, I’d prefer string as it’s a C# type alias and well-known by C# programmers.

I can say the same about (intSystem.Int32) etc.

String vs string in C# – Answer #4:

The best answer I have ever heard about using the provided type aliases in C# comes from Jeffrey Richter in his book CLR Via C#. Here are his 3 reasons:

  • I’ve seen a number of developers confused, not knowing whether to use string or String in their code. Because in C# the string (a keyword) maps exactly to System.String (an FCL type), there is no difference and either can be used.
  • In C#, long maps to System.Int64, but in a different programming language, long could map to an Int16 or Int32. In fact, C++/CLI does in fact treat long as an Int32. Someone reading source code in one language could easily misinterpret the code’s intention if he or she were used to programming in a different programming language. In fact, most languages won’t even treat long as a keyword and won’t compile code that uses it.
  • The FCL has many methods that have type names as part of their method names. For example, the BinaryReader type offers methods such as ReadBooleanReadInt32ReadSingle, and so on, and the System.Convert type offers methods such as ToBooleanToInt32ToSingle, and so on. Although it’s legal to write the following code, the line with float feels very unnatural to me, and it’s not obvious that the line is correct:
BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

So there you have it. I think these are all really good points. I however, don’t find myself using Jeffrey’s advice in my own code. Maybe I am too stuck in my C# world but I end up trying to make my code look like the framework code.

Answer #4:

string is a reserved word, but String is just a class name. This means that string cannot be used as a variable name by itself.

If for some reason you wanted a variable called string, you’d see only the first of these compiles:

StringBuilder String = new StringBuilder();  // compiles
StringBuilder string = new StringBuilder();  // doesn't compile 

If you really want a variable name called string you can use @ as a prefix:

StringBuilder @string = new StringBuilder();

Answer #5:

System.String is the .NET string class – in C# string is an alias for System.String – so in use they are the same.

As for guidelines I wouldn’t get too bogged down and just use whichever you feel like – there are more important things in life and the code is going to be the same anyway.

If you find yourselves building systems where it is necessary to specify the size of the integers you are using and so tend to use Int16Int32UInt16UInt32 etc. then it might look more natural to use String – and when moving around between different .net languages it might make things more understandable – otherwise I would use string and int.

Answer #6:

I prefer the capitalized .NET types (rather than the aliases) for formatting reasons. The .NET types are colored the same as other object types (the value types are proper objects, after all).

Conditional and control keywords (like ifswitch, and return) are lowercase and colored dark blue (by default). And I would rather not have the disagreement in use and format.

Consider:

String someString; 
string anotherString; 

Answer #7:

This YouTube video demonstrates practically how they differ.

But now for a long textual answer.

When we talk about .NET there are two different things one there is .NET framework and the other there are languages (C#VB.NET etc) which use that framework.

enter image description here

System.String” a.k.a “String” (capital “S”) is a .NET framework data type while “string” is a C# data type.

enter image description here

In short “String” is an alias (the same thing called with different names) of “string”. So technically both the below code statements will give the same output.

String s = "I am String";

or

string s = "I am String";

In the same way, there are aliases for other C# data types as shown below:

object: System.Object, string: System.String, bool: System.Boolean, byte: System.Byte, sbyte: System.SByte, short: System.Int16 and so on.

Now the million-dollar question from programmer’s point of view: So when to use “String” and “string”?

The first thing to avoid confusion use one of them consistently. But from best practices perspective when you do variable declaration it’s good to use “string” (small “s”) and when you are using it as a class name then “String” (capital “S”) is preferred.

In the below code the left-hand side is a variable declaration and it is declared using “string”. On the right-hand side, we are calling a method so “String” is more sensible.

string s = String.ToUpper() ;

Hope you learned something from this post.

Follow Programming Articles for more!

About ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ

Linux and Python enthusiast, in love with open source since 2014, Writer at programming-articles.com, India.

View all posts by ᴾᴿᴼᵍʳᵃᵐᵐᵉʳ →