Generic class declaration in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Generic class declaration

Start

↓

Declare generic class with <T>

↓

Create instance with specific type

↓

Use class members with type T

↓

End

This flow shows declaring a generic class with a placeholder type T, creating an instance with a real type, and using its members.

Execution Sample

C Sharp (C#)

public class Box<T>
{
    public T Value;
    public Box(T value) { Value = value; }
}

Declares a generic class Box with a type parameter T and a constructor to set its Value.

Execution Table

Step	Action	Type Parameter T	Value	Notes
1	Declare class Box<T>	T is a placeholder	No value yet	Class template created
2	Create Box<int> instance with 5	T = int	Value = 5	Instance stores int value 5
3	Create Box<string> instance with "Hi"	T = string	Value = "Hi"	Instance stores string value "Hi"
4	Access Value of Box<int>	T = int	5	Returns stored int value
5	Access Value of Box<string>	T = string	"Hi"	Returns stored string value
6	End	-	-	Execution complete

💡 All instances created and values accessed, demonstrating generic class usage.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
Box<int>.Value	undefined	5	5	5
Box<string>.Value	undefined	undefined	"Hi"	"Hi"

Key Moments - 3 Insights

Why do we use <T> in the class declaration?

The <T> is a placeholder for any type. It lets us create one class that works with many types, as shown in steps 1 and 2 of the execution_table.

What happens when we create Box<int> vs Box<string>?

Creating Box<int> sets T to int, so Value holds an int. Creating Box<string> sets T to string, so Value holds a string. This is shown in steps 2 and 3.

Can we use the generic class without specifying a type?

No, you must specify a type when creating an instance, like Box<int> or Box<string>. The class alone is just a template (step 1).

Visual Quiz - 3 Questions

Look at the execution_table, what is the type of T when creating Box<string>?

A int

B string

C T placeholder

D object

💡 Hint

Check step 3 in the execution_table where Box is created.

At which step does the Box<int> instance get its Value set to 5?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the action column in step 2 of the execution_table.

If we create Box<double> with 3.14, how would the variable_tracker change?

A Change Box<int>.Value to 3.14

B Replace Box<string>.Value with 3.14

C Add a new row for Box<double>.Value with 3.14 after creation

D No change needed

💡 Hint

Variable tracker shows each type's Value separately, see rows for int and string.

Concept Snapshot

Generic class declaration syntax:
public class ClassName<T> { ... }
T is a placeholder type used inside the class.
Create instances with real types: ClassName<int>, ClassName<string>.
Allows one class to work with many data types safely.

Full Transcript

This lesson shows how to declare a generic class in C#. The class uses a placeholder type T, which is replaced by a real type when creating an instance. For example, Box<int> stores an int value, and Box<string> stores a string. The execution table traces declaring the class, creating instances, and accessing their values. The variable tracker shows how the Value field changes for each type. Key moments clarify why <T> is used and how instances differ by type. The quiz tests understanding of type substitution and instance creation. This helps beginners see how generics make code reusable and type-safe.