String vs string in C#

Question

In C# the string keyword (highlighted in Visual Studio as a data type) is just a shortcut to the String class right?

In that case, it would be the same to use either while coding from the semantic point of view. However, is it the same from the performance point of view? I mean, when the mapping is performed: during compilation (I guess so), during compilation or during JIT compilation in execution?

Or maybe this is all wrong: string and String are not the same thing in C# so there are some situations where they cannot be interchanged

Answer 1

string and String are identical in all ways (except the uppercase "S"). There are no performance implications either way.

Lowercase "string" is preferred in most projects due to the syntax highlighting

Answer 2

string is just an alias for System.String. The compiler will treat them identical.

The only practical difference is the syntax highlighting as you mention, and that you have to write "using System" if you use String.

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-know by C# programmers.

I can say the same about (int, System.Int32) etc..

Answer 4

Both are same. But from coding guidelines perspective it's better to use string instead of String. This is what generally developers use. e.g. instead of using Int32 we use int as int is alias to Int32 FYI “The keyword string is simply an alias for the predefined class System.String.” - C# Language Specification 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

Answer 5

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. 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, 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

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 which defines an "int" alias for Int16, for example. The .NET framework designers have followed this pattern, good examples being in the BitConverter, BinaryReader and Convert classes.

Answer 6

This question was essentially covered here and here already.

Answer 7

It's been covered above; however, you can't use 'string' in reflection; you must use "String".

Answer 8

As the others are saying, they're the same. StyleCop rules, by default, will enforce you to use 'string' as a C# code style best practice, except when referencing System.String static functions, such as String.Format, String.Join, String.Concat, etc...

Answer 9

I just wrote a short article on this topic, check it out on this link.