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.

Practice

1.

What is the main purpose of declaring a generic class in C# using <T>?

easy

A. To allow the class to work with any data type safely

B. To restrict the class to only one specific data type

C. To make the class run faster by avoiding type checks

D. To create multiple classes with different names automatically

Solution

1. Step 1: Understand generic class purpose

   Generic classes use type parameters to work with any data type, improving code reuse and safety.

2. Step 2: Compare options with generic concept

   Only To allow the class to work with any data type safely correctly states that generics allow safe use with any data type.

3. Final Answer:

   To allow the class to work with any data type safely -> Option A

4. Quick Check:

   Generic class purpose = safe, reusable code [OK]

Hint: Generics = flexible types for safe reuse [OK]

Common Mistakes:

• Thinking generics restrict to one type
• Believing generics improve speed by skipping checks
• Confusing generics with automatic class creation

2.

Which of the following is the correct syntax to declare a generic class named Box with one type parameter?

?

easy

A. public class Box<T>() { }

B. public class Box<T> { }

C. public class Box(T) { }

D. public class Box[] { }

Solution

1. Step 1: Recall generic class syntax

   Generic classes use angle brackets with type parameters: class ClassName<T>.

2. Step 2: Check each option

   public class Box<T> { } matches correct syntax. Options A, B, and D have syntax errors or wrong symbols.

3. Final Answer:

   public class Box<T> { } -> Option B

4. Quick Check:

   Generic syntax = class Name<T> [OK]

Hint: Generic classes use angle brackets <> [OK]

Common Mistakes:

• Using parentheses instead of angle brackets
• Adding parentheses after class name
• Using square brackets instead of angle brackets

3.

What will be the output of the following C# code?

public class Container<T> {
    public T Value;
    public Container(T value) { Value = value; }
    public override string ToString() => $"Value: {Value}";
}

var intBox = new Container<int>(10);
var strBox = new Container<string>("Hello");
Console.WriteLine(intBox);
Console.WriteLine(strBox);

medium

A. Value: 10
Value: Hello

B. Value: intBox
Value: strBox

C. 10
Hello

D. Compilation error due to missing type constraints

Solution

1. Step 1: Understand class behavior

   The class stores a value of type T and overrides ToString() to print "Value: {Value}".

2. Step 2: Trace output of Console.WriteLine

   intBox.ToString() returns "Value: 10" and strBox.ToString() returns "Value: Hello".

3. Final Answer:

   Value: 10 Value: Hello -> Option A

4. Quick Check:

   ToString override prints value with prefix [OK]

Hint: ToString() shows formatted value, not variable name [OK]

Common Mistakes:

• Expecting variable names instead of values
• Ignoring ToString() override
• Thinking type constraints are required here

4.

Identify the error in this generic class declaration and fix it:

public class Pair<T, U>
{
    public T First;
    public U Second;

    public Pair(T first, U second)
    {
        First = first;
        Second = second;
    }
}

var p = new Pair<string>(5, "test");

medium

A. Generic class cannot have two type parameters

B. Constructor parameters should be swapped

C. Missing type arguments when creating instance: use new Pair<int, string>(5, "test")

D. Fields First and Second must be private

Solution

1. Step 1: Check instance creation syntax

   Generic classes require type arguments when instantiated unless using C# 7.1+ with target-typed new.

2. Step 2: Identify missing type arguments

   The code uses new Pair<string>(5, "test") without specifying <int, string>, causing error.

3. Final Answer:

   Missing type arguments when creating instance: use new Pair<int, string>(5, "test") -> Option C

4. Quick Check:

   Generic instantiation needs type args [OK]

Hint: Always specify type parameters when creating generic instances [OK]

Common Mistakes:

• Omitting type arguments on new
• Thinking generic classes can't have multiple parameters
• Changing constructor parameter order unnecessarily

5.

You want to create a generic class Cache<TKey, TValue> that stores key-value pairs and only allows reference types for TValue. Which declaration is correct?

hard

A. public class Cache<TKey, TValue> where TKey : struct { }

B. public class Cache<TKey, TValue> where TValue : struct { }

C. public class Cache<TKey, TValue> where TKey : class { }

D. public class Cache<TKey, TValue> where TValue : class { }

Solution

1. Step 1: Understand type constraints

   To restrict a generic type to reference types, use where Type : class.

2. Step 2: Apply constraint to TValue

   The question requires TValue to be a reference type, so constraint applies to TValue.

3. Final Answer:

   public class Cache<TKey, TValue> where TValue : class { } -> Option D

4. Quick Check:

   Reference type constraint = where TValue : class [OK]

Hint: Use 'where TValue : class' to restrict to reference types [OK]

Common Mistakes:

• Applying constraint to wrong type parameter
• Using 'struct' instead of 'class' for reference types
• Omitting constraints when needed