Question

Not found it in StyleCop Help Manual, on SO and Google so here it is 😉

During StyleCop use I have a warning:

SA1121 – UseBuiltInTypeAlias –
Readability Rules

The code uses one of the basic C#
types, but does not use the built-in
alias for the type.

Rather than using the type name or the
fully-qualified type name, the
built-in aliases for these types
should always be used: bool, byte,
char, decimal, double, short, int,
long, object, sbyte, float, string,
ushort, uint, ulong.

so String.Empty is wrong (depend on above rules) and string.Empty is good.

Why using built-in aliases is better? Can String. Int32, Int64 (etc.) complicate something in the code on special scenarios?

Answer 1

Just to clarify: not everyone agrees with the authors of StyleCop. Win32 and .NET guru Jeffrey Richter writes in his excellent book CLR via C#:

The C# language specification states, “As a matter of style, use of the keyword is favored over
use of the complete system type name.” I disagree with the language specification; I prefer
to use the FCL type names and completely avoid the primitive type names. In fact, I wish that
compilers didn’t even offer the primitive type names and forced developers to use the FCL
type names instead. Here are my reasons:

• I’ve seen a number of developers confused, not knowing whether to use string
  or String in their code. Because in C# string (a keyword) maps exactly to
  System.String (an FCL type), there is no difference and either can be used. Similarly,
  I’ve heard some developers say that int represents a 32-bit integer when the application
  is running on a 32-bit OS and that it represents a 64-bit integer when the application
  is running on a 64-bit OS. This statement is absolutely false: in C#, an int always maps
  to System.Int32, and therefore it represents a 32-bit integer regardless of the OS the
  code is running on. If programmers would use Int32 in their code, then this potential
  confusion is also eliminated.

• 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 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 ReadBoolean, ReadInt32,
  ReadSingle, and so on, and the System.Convert type offers methods such as
  ToBoolean, ToInt32, ToSingle, 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
  

• Many programmers that use C# exclusively tend to forget that other programming
  languages can be used against the CLR, and because of this, C#-isms creep into the
  class library code. For example, Microsoft’s FCL is almost exclusively written in C# and
  developers on the FCL team have now introduced methods into the library such as
  Array’s GetLongLength, which returns an Int64 value that is a long in C# but not
  in other languages (like C++/CLI). Another example is System.Linq.Enumerable’s
  LongCount method.