Integer types and their ranges in C Sharp (C#)

Introduction

Integer types let you store whole numbers in your program. Knowing their ranges helps you pick the right type so numbers fit without errors.

When you need to count items like people or objects.

When you want to store ages, years, or other whole numbers.

When you want to save memory by choosing the smallest type that fits your numbers.

When you want to avoid errors from numbers being too big or too small.

Syntax

C Sharp (C#)

int myNumber = 100;
long bigNumber = 10000000000L;
short smallNumber = 30000;
byte tinyNumber = 255;

Integer types include byte, short, int, and long.

Each type has a fixed range of values it can hold.

Examples

byte stores numbers from 0 to 255, good for small positive numbers.

C Sharp (C#)

byte age = 25;

short stores numbers from -32,768 to 32,767, useful for small negative or positive numbers.

C Sharp (C#)

short temperature = -10;

int stores numbers from about -2 billion to 2 billion, common for general counting.

C Sharp (C#)

int population = 1000000;

long stores very large numbers, from about -9 quintillion to 9 quintillion.

C Sharp (C#)

long distance = 9000000000000L;

Sample Program

This program shows the range of each integer type and prints example values stored in variables.

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
        byte small = 255;
        short medium = -32000;
        int normal = 2000000000;
        long large = 9000000000000000000L;

        Console.WriteLine($"byte range: 0 to {byte.MaxValue}");
        Console.WriteLine($"short range: {short.MinValue} to {short.MaxValue}");
        Console.WriteLine($"int range: {int.MinValue} to {int.MaxValue}");
        Console.WriteLine($"long range: {long.MinValue} to {long.MaxValue}");

        Console.WriteLine($"Values stored: {small}, {medium}, {normal}, {large}");
    }
}

Important Notes

Use byte for small positive numbers only.

Use short or int for medium-sized numbers, depending on range.

Use long when numbers are very large.

Summary

Integer types store whole numbers with different size limits.

Choose the smallest type that fits your number to save memory.

Always check the range to avoid errors from numbers being too big or too small.

Practice

1. Which C# integer type can store values from -128 to 127?

easy

A. int

B. byte

C. short

D. sbyte

Solution

1. Step 1: Recall the range of sbyte

   The sbyte type stores signed 8-bit integers from -128 to 127.

2. Step 2: Compare with other types

   byte stores 0 to 255 (unsigned), short stores -32,768 to 32,767, and int stores much larger values.

3. Final Answer:

   sbyte -> Option D

4. Quick Check:

   Range -128 to 127 = sbyte [OK]

Hint: Remember sbyte is signed 8-bit: -128 to 127 [OK]

Common Mistakes:

• Confusing byte (unsigned) with sbyte
• Choosing short which has a larger range
• Assuming int is smallest

2. Which of the following is the correct way to declare a variable of type uint in C#?

easy

A. uint number = -1;

B. uint number = 4294967295;

C. uint number = 4294967296;

D. uint number = 3.14;

Solution

1. Step 1: Understand uint range

   uint is unsigned 32-bit integer with range 0 to 4,294,967,295.

2. Step 2: Check each assignment

   uint number = -1; assigns -1 (negative) which is invalid. uint number = 4294967295; assigns max valid value 4,294,967,295. uint number = 4294967296; assigns 4,294,967,296 which is too large. uint number = 3.14; assigns a decimal which is invalid for integer type.

3. Final Answer:

   uint number = 4294967295; -> Option B

4. Quick Check:

   uint max = 4294967295 [OK]

Hint: uint stores 0 to 4,294,967,295 only [OK]

Common Mistakes:

• Assigning negative values to unsigned types
• Using values larger than max range
• Assigning decimal numbers to integer types

3. What will be the output of this C# code?

short a = 30000;
short b = 10000;
int c = a + b;
Console.WriteLine(c);

medium

A. 40000

B. -25536

C. OverflowException

D. Compile-time error

Solution

1. Step 1: Understand variable types and addition

   Variables a and b are short (16-bit signed), but addition promotes them to int automatically.

2. Step 2: Calculate the sum and output

   30000 + 10000 = 40000 fits in int range, so c stores 40000 and prints it.

3. Final Answer:

   40000 -> Option A

4. Quick Check:

   30000 + 10000 = 40000 [OK]

Hint: short addition promotes to int, no overflow here [OK]

Common Mistakes:

• Expecting overflow because sum exceeds short max
• Thinking addition stays in short type
• Confusing runtime overflow with compile error

4. Identify the error in this C# code snippet:

byte x = 255;
byte y = 1;
byte z = (byte)(x + y);
Console.WriteLine(z);

medium

A. Output is 0 due to overflow wrap-around

B. Compile-time error due to overflow

C. No error, output is 256

D. Runtime exception thrown

Solution

1. Step 1: Analyze addition and casting

   Addition of x + y is done as int (255 + 1 = 256). Casting to byte truncates to 8 bits.

2. Step 2: Understand overflow wrap-around

   Since byte max is 255, 256 wraps around to 0 due to overflow without exception.

3. Final Answer:

   Output is 0 due to overflow wrap-around -> Option A

4. Quick Check:

   256 mod 256 = 0 [OK]

Hint: Casting int > 255 to byte wraps around [OK]

Common Mistakes:

• Expecting output 256 which is invalid for byte
• Thinking compile or runtime error occurs
• Ignoring overflow wrap-around behavior

5. You need to store the population of a city which can be up to 5 billion. Which C# integer type should you use to avoid overflow?

hard

A. int

B. uint

C. long

D. short

Solution

1. Step 1: Check the required range

   5 billion is 5,000,000,000 which exceeds int max (2,147,483,647) and uint max (4,294,967,295).

2. Step 2: Choose type with sufficient range

   long is a signed 64-bit integer with range ±9 quintillion, enough to store 5 billion safely.

3. Final Answer:

   long -> Option C

4. Quick Check:

   5 billion < long max [OK]

Hint: Use long for numbers bigger than int or uint max [OK]

Common Mistakes:

• Choosing int or uint which are too small
• Using short which is very small
• Not considering signed vs unsigned range