C# Generic Method

Generic methods have type parameters. They provide a way to parameterize the types used in a method. This means you can provide only one implementation and call it with different types. Generic methods require an unusual syntax form.

This C# example program shows how to create generic methods and call them.

Example

This program demonstrates the use of a generic method in the C# language. Generic methods use at least one explicit type parameter, which is customarily the type T or V or TValue or similar. This type is an open type, meaning it is not precisely described in the program source and few assumptions about its representation can be made.

Note: The syntax form for the declaration uses the <T> characters after the method name but before the formal parameter list.

Program that declares generic method [C#]

using System;
using System.Collections.Generic;

class Program
{
    static List<T> GetInitializedList<T>(T value, int count)
    {
	// This generic method returns a List with ten elements initialized.
	// ... It uses a type parameter.
	// ... It uses the "open type" T.
	List<T> list = new List<T>();
	for (int i = 0; i < count; i++)
	{
	    list.Add(value);
	}
	return list;
    }

    static void Main()
    {
	// Use the generic method.
	// ... Specifying the type parameter is optional here.
	// ... Then print the results.
	List<bool> list1 = GetInitializedList(true, 5);
	List<string> list2 = GetInitializedList<string>("Perls", 3);
	foreach (bool value in list1)
	{
	    Console.WriteLine(value);
	}
	foreach (string value in list2)
	{
	    Console.WriteLine(value);
	}
    }
}

Output

True
True
True
True
True
Perls
Perls
Perls

Overview. This program uses a generic method to construct a List with a certain number of elements of a certain type and with a specific initial value. The GetInitializedList member is the generic method and it uses a type parameter with name T.

The first parameter to the method is also a value of type T; when you specify the type parameter, you can access the type parameter from other parts of the method signature as shown.

Output. Finally, the program proves the correctness of the logic in the GetInitializedList method. It prints the values of a five-element List of Booleans, and the values of the three-element List of strings. Each of those values has the value we specified in the two method invocations to the GetInitializedList call.

Specification

Let's examine the C# language specification's description of type parameters in classes and methods. The specification describes in precise detail all of the results for computing type inference matches. It describes the algorithm used by the language compiler. However, these details are not useful for most programs.

Tip: Don't rely on language specification details in your program. Most developers do not study language specifications at length.

Disambiguation. Much complexity in generic methods and the algorithms they are implemented with involves disambiguation, the process by which the exact method you want to invoke is searched for and selected. This is also referred to as part of method overload resolution. You can omit the type parameter in the method invocations typically, but not in cases where the method call cannot be determined from the context.

Examples

In C# programming, many methods you call in programs may actually be generic methods. For example, the Array.Resize and Array.IndexOf methods are implemented as generic methods. This provides them with a performance boost over a version that uses explicit casting, and possible improved reliability. Please see the Array.Resize article for another syntax example.

Summary

We examined generic methods in the C# language and how they can be declared and invoked in the program text. Further, we touched on the concept of open types and type parameters and the syntax forms these are represented with; the problem of disambiguation and type inference.