Integer types and their ranges in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Integer types and their ranges

Start

↓

Choose integer type

↓

Check size in bits

↓

Determine range

↓

Use type in code

↓

End

This flow shows how to pick an integer type, check its size, find its range, and use it in code.

Execution Sample

C Sharp (C#)

int a = 100;
byte b = 255;
short c = -32768;
long d = 9223372036854775807;

This code declares variables of different integer types with values at or near their limits.

Execution Table

Step	Variable	Type	Value Assigned	Range Min	Range Max	Valid Assignment?
1	a	int	100	-2,147,483,648	2,147,483,647	Yes
2	b	byte	255	0	255	Yes
3	c	short	-32768	-32,768	32,767	Yes
4	d	long	9223372036854775807	-9,223,372,036,854,775,808	9,223,372,036,854,775,807	Yes
5	b	byte	256	0	255	No - exceeds max
6	c	short	-40000	-32,768	32,767	No - below min

💡 Execution stops after checking valid and invalid assignments for integer types.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
a	undefined	100	100	100	100
b	undefined	undefined	255	255	255
c	undefined	undefined	undefined	-32768	-32768
d	undefined	undefined	undefined	undefined	9223372036854775807

Key Moments - 2 Insights

Why can't we assign 256 to a byte variable?

Because byte can only hold values from 0 to 255, as shown in execution_table row 5 where 256 is outside the range.

Why is -32768 valid for short but -40000 is not?

Short ranges from -32,768 to 32,767, so -32768 is valid but -40000 is below the minimum, as shown in execution_table rows 3 and 6.

Visual Quiz - 3 Questions

Look at the execution_table, what is the maximum value a long variable can hold?

A 2,147,483,647

B 255

C 9,223,372,036,854,775,807

D 32,767

💡 Hint

Check the 'Range Max' column for variable 'd' in execution_table row 4.

At which step does the assignment become invalid because the value is too large for the type?

A Step 2

B Step 5

C Step 3

D Step 1

💡 Hint

Look at the 'Valid Assignment?' column in execution_table for the first 'No' entry.

If we assign 0 to a byte variable, what would change in the variable_tracker?

A Value of b after step 2 would be 0

B Value of a after step 1 would be 0

C Value of c after step 3 would be 0

D Value of d after step 4 would be 0

💡 Hint

Variable 'b' is byte type; check variable_tracker column 'After Step 2'.

Concept Snapshot

Integer types in C# include byte, short, int, and long.
Each type has a fixed size and range.
byte: 0 to 255 (8 bits)
short: -32,768 to 32,767 (16 bits)
int: -2,147,483,648 to 2,147,483,647 (32 bits)
long: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 (64 bits)
Assigning values outside these ranges causes errors.

Full Transcript

This visual execution shows how integer types in C# have specific ranges based on their size in bits. We start by choosing a type, then check its size and range. The code sample assigns values to variables of types int, byte, short, and long. The execution table tracks each assignment, showing if the value fits within the type's range. For example, byte can hold 0 to 255, so 255 is valid but 256 is not. The variable tracker shows how variable values change step by step. Key moments clarify why some assignments fail, like assigning 256 to a byte. The quiz tests understanding of ranges and valid assignments. The snapshot summarizes the ranges and rules for integer types in C#.

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