C# Int and uint Types

Evaluate the int and uint types. Use the 4-byte integer type in a program.
Int and unit. Think of the smallest thing you can touch—like the head of a pin. It takes a great deal of effort to deal with tiny things. A larger thing, like a wrench, is easier to use.
In computer programs, a larger, standard type (like int) is easier to access than a smaller one (like a bit). Int has advantages. It has optimized performance.
System.Int32 information: int.MinValue = -2147483648 int.MaxValue = 2147483647 System.UInt32 information: uint.MinValue = 0 uint.MaxValue = 4294967295
Int example. We declare and assign an int. It will be placed into a local variable slot in the stack memory. You can use Console.WriteLine to output the integer to the screen.

Also: You can compare 2 integers (variables or values) using the == (equality) operator. This compares all the bits for equivalence.

Min, Max: The int type also has MinValue and MaxValue properties. These are useful for when you want to loop through all integers.


4 bytes: The second part of the program shows that each integer, when allocated as part of an array, will occupy 4 bytes.

C# program that uses an int type using System; class Program { static void Main() { // Demonstrates an int value type used as local variable. int number = 11; Console.WriteLine(number); number = -1; // Can be negative Console.WriteLine(number); Console.WriteLine(number == -1); // Can use == operator Console.WriteLine(number + 100); // Can use + operator Console.WriteLine(number.GetType()); Console.WriteLine(typeof(int)); Console.WriteLine(int.MinValue); Console.WriteLine(int.MaxValue); // Find the memory usage for an int value in a large array. long bytes1 = GC.GetTotalMemory(false); int[] array = new int[1000 * 1000]; array[0] = 1; long bytes2 = GC.GetTotalMemory(false); Console.WriteLine(((bytes2 - bytes1) / (1000 * 1000)) .ToString("0 bytes per int")); } } Output 11 -1 True 99 System.Int32 System.Int32 -2147483648 2147483647 4 bytes per int
Int arguments. We use int as a parameter. You can pass a variable or a constant to the method that uses an integer parameter. An int argument is a common type.

Copied: The arguments are copied to the new method whenever it is called, but this cost is reduced when functions are inlined.


IsOdd: The program shows the boolean method pattern. This can help simplify complex tests.

Odd, Even
C# program that uses int argument to method using System; class Program { static void Main() { // Use integer type as argument to method. bool result = IsOdd(1); Console.WriteLine(result); // Test call the method with different integers. result = IsOdd(6); Console.WriteLine(result); result = IsOdd(100); Console.WriteLine(result); result = IsOdd(101); Console.WriteLine(result); } static bool IsOdd(int number) { // Use the integer parameter in the method body. return number % 2 != 0; } } Output True False False True
Int parse. Often a string contains characters that could be represented in an int variable. We can convert the string into an int with the int.Parse or int.TryParse methods.Parse
Int performance. As a field in a class, an int requires 4 bytes. But a smaller type (byte) may be sufficient for small numbers. This may improve spatial locality.Byte

So: If your program needs to store many thousands of integers in memory, a more compact type that requires less memory would be faster.

And: More compact types include the byte type, short type or ushort type. These can be packed together.

Int, short performance. Incrementing an int as a loop variable is faster than using a short or ushort (see the linked benchmark). Use int in local variables when possible.short, ushort
Uint example. Uint is similar to int, but reserves no space for the sign. Unsigned integers can be used through many programs. With uint we can increase the bounds of a loop.

Alias: The uint type is the same as the System.UInt32 type in the System namespace. This alias provides for clearer code in programs.


Example: We see some differences between uints and ints, such as the MinValue and MaxValue.

Fast: When code that uses uint is executed, it is allocated in the method's stack. No dynamic heap allocation is done. This is efficient.

C# program that uses uint type using System; class Program { static void Main() { // Declare example unsigned and signed integers. uint value1 = 100; int value2 = 100; // Display values. Console.WriteLine(value1); Console.WriteLine(value2); // Assign the maximum values. uint max1 = uint.MaxValue; int max2 = int.MaxValue; // Display maximum values. Console.WriteLine(max1); Console.WriteLine(max2); // Assign the minimum values. uint min1 = uint.MinValue; int min2 = int.MinValue; // Write the minimum values. Console.WriteLine(min1); Console.WriteLine(min2); // Write the types. Console.WriteLine(typeof(uint)); Console.WriteLine(typeof(int)); } } Output 100 100 4294967295 2147483647 0 -2147483648 System.UInt32 System.Int32
Uint range. MaxValue is equal to 4294967295. This is invariant and will always be true. There is no advantage to hard-coding 4294967295.

And: MinValue on the System.UInt32 type is also a constant in the base class library. This field is always equal to zero.

Tip: This is true because uints lack the sign bit that, when set, makes a number equal a negative value.

Uint typeof. The above program displays the System.Type object for the 2 numeric types. This shows the struct that uint aliases to.
Int errors. If you try to assign an int variable in your program to a numeric literal that is too big, the C# compiler will give you a compile-time error.

So: For example, try compiling the code "int value1 = 3000000000". The C# compiler will give the error here.

Tip: If you change the "int" type to "uint", your program will compile successfully.

Error: Cannot implicitly convert type uint to int An explicit conversion exists (are you missing a cast?)
Null int. An int can never be null. But we can use a nullable int, which is a struct that wraps around an int value, to represent a null int.

Info: A nullable int can be tested directly against null. This makes it different from a class instance that has an int field.

C# program that uses nullable int using System; class Program { static void Main() { // A nullable int can be a number, or null. int? test = 100; Console.WriteLine("Value is {0}", test.Value); test = null; Console.WriteLine("Null: {0}", test == null); } } Output Value is 100 Null: True
A summary. Int is found in almost every program (uint is less common). Int is exceedingly useful and simple to understand. It can be considered the default number type.
© 2007-2019 Sam Allen. Every person is special and unique. Send bug reports to
Dot Net Perls