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

Concept Flow - Generic method declaration

Start method call

↓

Specify type parameter <T>

↓

Method body uses T

↓

Execute method with T

↓

Return result of type T

↓

End method call

The generic method starts by specifying a type parameter T, then uses T inside the method body, and finally returns a value of type T.

Execution Sample

C Sharp (C#)

public T Echo<T>(T input) {
    return input;
}

var result = Echo<int>(5);

This method returns the input value of any type T. Here, it is called with int and returns 5.

Execution Table

Step	Action	Type Parameter T	Input Value	Return Value
1	Call Echo<int>(5)	int	5	N/A
2	Enter method body	int	5	N/A
3	Return input	int	5	5
4	Assign return to result	int	N/A	5

💡 Method returns input value 5 of type int, execution ends.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
T	undefined	int	int	int	int
input	undefined	5	5	5	5
result	undefined	undefined	undefined	undefined	5

Key Moments - 3 Insights

Why do we write <T> after the method name?

The <T> declares a placeholder type that the method can use. This is shown in execution_table step 1 where T is set to int.

How does the method know what type T is?

When calling the method, we specify the type (like Echo<int>), so T becomes int as shown in variable_tracker after step 1.

What type does the method return?

It returns the same type T that was passed in, as seen in execution_table step 3 where return value is 5 of type int.

Visual Quiz - 3 Questions

Look at the execution_table, what is the type of T at step 2?

A string

B int

C undefined

D object

💡 Hint

Check the 'Type Parameter T' column at step 2 in execution_table.

At which step does the method return the input value?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look for 'Return input' action in execution_table.

If we call Echo<string>("hello"), what would be the return value type?

A int

B bool

C string

D object

💡 Hint

Refer to how T is set in variable_tracker and execution_table for int; string would behave similarly.

Concept Snapshot

Generic method declaration syntax:
public T MethodName<T>(T param) { ... }

- <T> declares a type placeholder.
- Method uses T as a type inside.
- Caller specifies T when calling.
- Method returns or uses values of type T.

Full Transcript

This example shows a generic method named Echo that takes a parameter of type T and returns it. When calling Echo<int>(5), the type parameter T becomes int. The method receives input 5, returns it, and the result is assigned to variable result. The execution table traces each step: calling the method, entering the body, returning the input, and assigning the result. Variables T, input, and result change accordingly. Key points include understanding the <T> syntax, how the type is specified at call time, and that the method returns the same type. The quiz questions check understanding of the type parameter and return value.

Practice

1. What is the purpose of declaring a generic method in C# using <T>?

easy

A. To allow the method to work with any data type specified when called

B. To restrict the method to only work with integers

C. To make the method private

D. To declare a method that returns void only

Solution

1. Step 1: Understand generic method declaration

   Generic methods use <T> to represent a placeholder for any type, making the method flexible.

2. Step 2: Identify the purpose of <T>

   The <T> allows the method to accept or return any type specified at call time, improving reuse.

3. Final Answer:

   To allow the method to work with any data type specified when called -> Option A

4. Quick Check:

   Generic <T> means flexible type [OK]

Hint: Generic <T> means method works with any type [OK]

Common Mistakes:

• Thinking <T> restricts to one type like int
• Confusing generic methods with access modifiers
• Assuming generic methods always return void

2. Which of the following is the correct syntax to declare a generic method named PrintItem that takes one parameter of type T?

easy

A. public void PrintItem<T>(item T) { Console.WriteLine(item); }

B. public <T> void PrintItem(T item) { Console.WriteLine(item); }

C. public void PrintItem<T>(T item) { Console.WriteLine(item); }

D. public void PrintItem(T item) { Console.WriteLine(item); }

Solution

1. Step 1: Review generic method syntax

   The generic type parameter <T> must come immediately after the method name.

2. Step 2: Check parameter declaration

   The parameter should be declared as type T, followed by the parameter name.

3. Final Answer:

   public void PrintItem<T>(T item) { Console.WriteLine(item); } -> Option C

4. Quick Check:

   Generic <T> after method name, parameter type T [OK]

Hint: Put <T> right after method name for generics [OK]

Common Mistakes:

• Placing <T> before return type
• Omitting <T> after method name
• Swapping parameter type and name

3. What will be the output of the following code?

public class Program {
    public static void ShowType<T>(T value) {
        Console.WriteLine(typeof(T));
    }
    public static void Main() {
        ShowType(123);
        ShowType("hello");
    }
}

medium

A. 123
hello

B. System.Int32
System.String

C. T
T

D. System.Object
System.Object

Solution

1. Step 1: Understand typeof(T) in generic method

   typeof(T) returns the actual type used when the method is called.

2. Step 2: Analyze calls ShowType(123) and ShowType("hello")

   First call uses int (System.Int32), second uses string (System.String).

3. Final Answer:

   System.Int32 System.String -> Option B

4. Quick Check:

   typeof(T) shows actual type [OK]

Hint: typeof(T) prints actual type used at call [OK]

Common Mistakes:

• Expecting value output instead of type
• Thinking T is printed literally
• Assuming typeof(T) always returns System.Object

4. Identify the error in this generic method declaration:

public void Swap<T>(T a, T b) {
    T temp = a;
    a = b;
    b = temp;
}

medium

A. Cannot declare variable temp of type T

B. Missing generic type declaration <T> after method name

C. Method must return a value to swap

D. Cannot swap values because parameters are passed by value

Solution

1. Step 1: Check parameter passing

   Parameters a and b are passed by value, so swapping inside method won't affect caller.

2. Step 2: Confirm generic syntax correctness

   The method correctly declares <T> after method name and uses T type variables.

3. Final Answer:

   Cannot swap values because parameters are passed by value -> Option D

4. Quick Check:

   Value parameters can't swap caller variables [OK]

Hint: Swap needs ref/out to affect caller variables [OK]

Common Mistakes:

• Thinking generic syntax is wrong
• Assuming temp can't be type T
• Expecting method must return swapped values

5. You want to write a generic method FindMax that returns the maximum of two values of any type T. Which constraint should you add to T to make comparison possible?

hard

A. where T : IComparable<T>

B. where T : class

C. where T : new()

D. where T : struct

Solution

1. Step 1: Understand comparison requirement

   To compare two values of type T, T must support comparison operations.

2. Step 2: Identify suitable generic constraint

   IComparable<T> interface defines CompareTo method for comparing instances.

3. Step 3: Review other constraints

   class restricts to reference types, new() requires parameterless constructor, struct restricts to value types but no comparison guarantee.

4. Final Answer:

   where T : IComparable<T> -> Option A

5. Quick Check:

   Use IComparable<T> to enable comparisons [OK]

Hint: Use IComparable<T> constraint for comparing generics [OK]

Common Mistakes:

• Using class or struct constraints instead of IComparable
• Forgetting to add any constraint
• Assuming new() enables comparison