Integer types and their ranges in C Sharp (C#) - Mini Project: Build & Apply

Integer types and their ranges

📖 Scenario: You are working on a simple program to understand different integer types in C# and their value ranges. This knowledge helps you choose the right type for storing numbers efficiently.

🎯 Goal: Create variables of different integer types, find their minimum and maximum values, and display these ranges.

📋 What You'll Learn

Create variables of types byte, short, int, and long

Use the built-in properties MinValue and MaxValue to get the ranges

Print the ranges clearly with the type name and its minimum and maximum values

💡 Why This Matters

🌍 Real World

Understanding integer types and their ranges helps you choose the right data type for storing numbers efficiently in real applications, avoiding errors like overflow.

💼 Career

Many programming jobs require knowledge of data types and memory usage to write efficient and safe code, especially in systems programming, game development, and embedded systems.

1

Create variables for integer types

Create variables called myByte, myShort, myInt, and myLong with types byte, short, int, and long respectively. Assign any valid value to each variable.

C Sharp (C#)

// Your code here

Hint

Use the correct type names and assign values within their allowed ranges.

2

Create variables for minimum and maximum values

Create variables called byteMin, byteMax, shortMin, shortMax, intMin, intMax, longMin, and longMax. Assign them the minimum and maximum values of byte, short, int, and long using MinValue and MaxValue properties.

C Sharp (C#)

byte myByte = 100;
short myShort = 30000;
int myInt = 2000000000;
long myLong = 9000000000000000000L;
// Your code here

Hint

Use the type name followed by .MinValue or .MaxValue to get the range limits.

3

Write code to display the ranges

Use Console.WriteLine to print the ranges of each integer type. For example, print "byte range: 0 to 255" using the variables byteMin and byteMax. Do this for byte, short, int, and long.

C Sharp (C#)

byte myByte = 100;
short myShort = 30000;
int myInt = 2000000000;
long myLong = 9000000000000000000L;

byte byteMin = byte.MinValue;
byte byteMax = byte.MaxValue;
short shortMin = short.MinValue;
short shortMax = short.MaxValue;
int intMin = int.MinValue;
int intMax = int.MaxValue;
long longMin = long.MinValue;
long longMax = long.MaxValue;

// Your code here

Hint

Use string interpolation with $"...{variable}..." inside Console.WriteLine.

4

Run the program and check the output

Run the program and observe the printed output showing the ranges of byte, short, int, and long types.

C Sharp (C#)

byte myByte = 100;
short myShort = 30000;
int myInt = 2000000000;
long myLong = 9000000000000000000L;

byte byteMin = byte.MinValue;
byte byteMax = byte.MaxValue;
short shortMin = short.MinValue;
short shortMax = short.MaxValue;
int intMin = int.MinValue;
int intMax = int.MaxValue;
long longMin = long.MinValue;
long longMax = long.MaxValue;

Console.WriteLine($"byte range: {byteMin} to {byteMax}");
Console.WriteLine($"short range: {shortMin} to {shortMax}");
Console.WriteLine($"int range: {intMin} to {intMax}");
Console.WriteLine($"long range: {longMin} to {longMax}");

// Run and check output

Hint

Check the console output carefully for the exact ranges.

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