CODEWITHSUNDEEP
c#types
Michael Liu
Michael Liu

Reputation: 55509

When does it matter whether you use int versus Int32, or string versus String?

In C#, the keywords for built-in types are simply aliases for corresponding types in the System namespace.

Generally, it makes no difference whether you use a keyword (such as int) or an identifier (such as Int32) to refer to a built-in type. But there's an exception to everything, so my question in two parts is:

  1. When does C# require you to use, or not use, a keyword?
  2. When does using a keyword instead of an identifier change the meaning of the program?

Upvotes: 4

Views: 943

Answers (8)

Michael Liu
Michael Liu

Reputation: 55509

A using alias directive cannot use a keyword as the type name (but can use keywords in type argument lists):

using Handle = int; // error
using Handle = Int32; // OK
using NullableHandle = Nullable<int>; // OK

The underlying type of an enum must be specified using a keyword:

enum E : int { } // OK
enum E : Int32 { } // error

The expressions (x)+y, (x)-y, and (x)*y are interpreted differently depending on whether x is a keyword or an identifier:

(int)+y // cast +y (unary plus) to int
(Int32)+y // add y to Int32; error if Int32 is not a variable
(Int32)(+y) // cast +y to Int32

(int)-y // cast -y (unary minus) to int
(Int32)-y // subtract y from Int32; error if Int32 is not a variable
(Int32)(-y) // cast -y to Int32

(int)*y // cast *y (pointer indirection) to int
(Int32)*y // multiply Int32 by y; error if Int32 is not a variable
(Int32)(*y) // cast *y to Int32

Upvotes: 2

McKay
McKay

Reputation: 12624

It doesn't matter. int is basically a shorthand for System.Int32 they are almost perfectly interchangable. Consider it a #define if you like (but C# doesn't allow #defines like that).

Upvotes: 0

CodesInChaos
CodesInChaos

Reputation: 108880

One issue is that with strange usings or member declarations String/Int32 can map to a different type(i.e. not the one from mscorlib) or even another kind of member, which would lead to problems.

As Jon mentioned, another issue is that you can't declare enums using an identifier(You get the error "Type byte, sbyte, short, ushort, int, uint, long, or ulong expected").

Upvotes: 0

KeithS
KeithS

Reputation: 71591

The only situation I can think of in which you are required to use the aliases in a form where you might otherwise be able to use a class name is in the definition of enum types:

public enum MyEnum:Byte //will not compile

public enum MyEnum:byte //correct

Notice also that the definition of an enum requires use of the alias keyword, while when defining code members that can accept any enumerated type, you use the class name Enum.

Lastly, you can never specify System.ValueType as a base class or generic type parameter; you instead use the struct keyword, which is essentially an alias for an object deriving from ValueType.

Upvotes: 0

zaq
zaq

Reputation: 2661

It doesn't require you to use one or the other. However, if you want a larger or smaller int you might want to explicitly use Int16 or Int64 instead of int which is an alias for Int32.

Upvotes: 0

Yuck
Yuck

Reputation: 50855

The identifiers int, string, bool, etc. are C# language aliases for the real types Int32, String, and Boolean, respectively. It doesn't matter which you use, but when you're writing an API some people prefer to use the actual class types to the aliases.

Here's an MSDN article that lists the equivalents.

Upvotes: 1

Darin Dimitrov
Darin Dimitrov

Reputation: 1039438

C# doesn't require you to use one or the other as they are equivalent. It is a personal preference and coding convention. So use the one that seems more readable to you and your team. Just one advice: be consistent: do not use an alias in half of your codebase and the full type name in the second half.

Upvotes: 8

user596075
user596075

Reputation:

string is an alias for the type System.String, and int is an alias for System.Int32. Therefore, use to your preference.

Upvotes: 2

Related Questions