{"id":585,"date":"2022-05-01T15:56:26","date_gmt":"2022-05-01T08:56:26","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=585"},"modified":"2022-06-03T15:08:50","modified_gmt":"2022-06-03T08:08:50","slug":"csharp-generics","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-generics\/","title":{"rendered":"C# Generics"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# generics and how to define a generic method that works with any type.<\/p>\n\n\n\n

Introduction to the C# generics<\/h2>\n\n\n\n

C# generics allow you to write code that works with more than one type. By using generics, you can write code with placeholders for types and then provide the actual types when using the code.<\/p>\n\n\n\n

Suppose you need to write a method that swaps the values of two integer<\/a> variables. To do that, you can define a method called SwapInt()<\/code> that accepts two integer parameters like this:<\/p>\n\n\n

static<\/span> void<\/span> SwapInt<\/span>(ref<\/span> int<\/span> a, ref<\/span> int<\/span> b<\/span>)<\/span>\n{\n    int<\/span> temp = a;\n        a = b;\n        b = temp;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
static<\/span> void<\/span> SwapString<\/span>(ref<\/span> string<\/span> a, ref<\/span> string<\/span> b<\/span>)<\/span>\n{\n    string<\/span> temp = a;\n           a = b;\n           b = temp;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Both SwapInt()<\/code> and SwapString()<\/code> methods have the same logic except for the types of the variables that they deal with.<\/p>\n\n\n\n
To resolve this, you can create a generic method that swaps values of variables of any type like this:<\/p>\n\n\n
static<\/span> void<\/span> Swap<T>(ref<\/span> T a, ref<\/span> T b)\n{\n    T temp = a;\n      a = b;\n      b = temp;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this Swap()<\/code> method, instead of using a specific type, we use the placeholder T for the type. <\/p>\n\n\n\n
Note that the name of the placeholder T<\/code> is a community convention. It means that you can use any string like A, B, TYPE, etc.<\/p>\n\n\n\n
When using the Swap()<\/code> method, you can specify the specific type. For example:<\/p>\n\n\n
int<\/span> x = 10<\/span>, y = 20<\/span>;\n\nSwap<int<\/span>>(ref<\/span> x, ref<\/span> y);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, we specify the int<\/code> type inside the angle brackets (<><\/code>) that follows the method name. Since the types of x<\/code> and y<\/code> are int<\/code>, you can make the method call short like this:<\/p>\n\n\n
int<\/span> x = 10<\/span>, y = 20<\/span>;\n\nSwap(ref<\/span> x, ref<\/span> y);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The following program illustrates how to use the generic Swap()<\/code> method and uses it to swap values of two integers and two string variables:<\/p>\n\n\n
class<\/span> Program<\/span>\n{\n    static<\/span> void<\/span> Swap<T>(ref<\/span> T a, ref<\/span> T b)\n    {\n        T temp = a;\n        a = b;\n        b = temp;\n    }\n\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\n    {\n        \/\/ swap integers<\/span>\n        int<\/span> x = 10<\/span>, y = 20<\/span>;\n\n        Console.WriteLine($\"Before swapping: x={x}<\/span>,y={y}<\/span>\"<\/span>);\n        Swap(ref<\/span> x, ref<\/span> y);\n        Console.WriteLine($\"After swapping: x={x}<\/span>,y={y}<\/span>\"<\/span>);\n        \n        \/\/ swap strings<\/span>\n\n        string<\/span> s1 = \"hello\"<\/span>, s2 = \"goodbye\"<\/span>;\n\n        Console.WriteLine($\"Before swapping: s1={s1}<\/span>,s2={s2}<\/span>\"<\/span>);\n        Swap(ref<\/span> s1, ref<\/span> s2);\n        Console.WriteLine($\"After swapping: s1={s1}<\/span>,s2={s2}<\/span>\"<\/span>);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Before swapping: x=10,y=20\nAfter swapping: x=20,y=10\nBefore swapping: s1=hello,s2=goodbye\nAfter swapping: s1=goodbye,s2=hello<\/code><\/span>Code language:<\/span> plaintext<\/span> (<\/span>plaintext<\/span>)<\/span><\/small><\/pre>\n\n\n
C# allows you to use generics with the following:<\/p>\n\n\n\n
Imagine that you need to swap values of two variables of a new type e.g., float<\/a>, you need to define a new method for each new type. As the result, you’ll have lots of Swap*<\/code> methods with the same logic. <\/p>\n\n\n\n
Later, you want to swap the values of two string<\/a> variables. In this case, you need to define a new method that swaps the strings:<\/p>\n\n\n