Introduction to C# Generics
So, what is the concept of Generics in C#? In simple words, it is the concept of defining type-independent classes, interfaces, methods, delegates, properties, etc. This means that you can define a generic class or method body and provide the actual type during invocation.
Thus, Generics are like code-templates. They allow you to write a type-safe code-block without referring to any particular data-type. The type of your code is determined at compile-time during the invocation call for your class or method.
Syntax of Generics in C#
Let us look at the syntax of a generic declaration in C#. It is a very simple syntax.
As a common practice, the letter ‘T’, in the capital and enclosed within angular brackets, denotes the declaration of a generic code in C#. But, this is not the mandate. Any letter in capital case enclosed within angular brackets can be used to denote a Generic code.
Declaring a Generic Class:
public class MyGenericClass<U>
Instantiating a Generic Class:
MyGenericClass<int> = new MyGenericClass<int>();
Declaring a Generic Derived Class:
public class MyGenericDerivedClass<T> : MyGenericBaseClass<T>
Declaring a Generic Method:
public T MyGenericMethod(T item);
How Generics Work in C#?
When you declare a generic code in C#, the compiler produces a template equivalent to that code. This template is checked for all compilation errors except type-safety. The next step comes when the generic code is invoked or called in another part of the program. At the time of invocation, you specify the type that your generic code would be compiled with. When the compiler reaches the invocation point, it inserts the type specified in the previously compiled template. This is then re-compiled to check for type-safety. Once passed, the code is ready for execution.
We would see the compiled code in the examples below to get a better understanding of generic templates.
4.6 (6,920 ratings)
View Course
Example of Generics in C#
Below are the different examples of C# Generics:
Generics with Class
Code:
using System;
using System.Collections.Generic;
public class GenericClass<T>
{
List<T> genericList;
public GenericClass()
{
genericList = new List<T>();
}
public void AddToList(T item)
{
genericList.Add(item);
}
public void DisplayList()
{
foreach (var ele in genericList)
{
Console.Write("{0}\t", ele);
}
}
}
public class Program
{
public static void Main()
{
GenericClass<int> intGenericObj = new GenericClass<int>();
GenericClass<string> stringGenericObj = new GenericClass<string>();
intGenericObj.AddToList(28);
intGenericObj.AddToList(999);
intGenericObj.AddToList(0);
intGenericObj.AddToList(-123);
intGenericObj.AddToList(100);
stringGenericObj.AddToList("Hello");
stringGenericObj.AddToList("Bonjour");
stringGenericObj.AddToList("Ola");
stringGenericObj.AddToList("Ciao");
stringGenericObj.AddToList("Hallo");
intGenericObj.DisplayList();
Console.WriteLine("\n");
stringGenericObj.DisplayList();
}}
Output:
The same code can also be re-written as below. This illustrates the power of defining a generic class which can be made type-safe for multiple types in a single object.
using System;
using System.Collections.Generic;
public class GenericClass<T, U>
{
List<T> genericList1;
List<U> genericList2;
public GenericClass()
{
genericList1 = new List<T>();
genericList2 = new List<U>();
}
public void AddToList(T item1, U item2)
{
genericList1.Add(item1);
genericList2.Add(item2);
}
public void DisplayList()
{
foreach (var ele in this.genericList1)
{
Console.Write("{0}\t", ele);
}
Console.WriteLine("\n");
foreach (var ele in this.genericList2)
{
Console.Write("{0}\t", ele);
}
}
}
public class Program
{
public static void Main()
{
GenericClass<int, string> genericObj = new GenericClass<int, string>();
genericObj.AddToList(28, "Hello");
genericObj.AddToList(999, "Bonjour");
genericObj.AddToList(0, "Ola");
genericObj.AddToList(-123, "Ciao");
genericObj.AddToList(100, "Hallo");
genericObj.DisplayList();
}
}
Output:
Compiled Code:
To get a perspective of how the data-type is resolved in Generics, let us look at the compiled code generated when we instantiate the class with integer and string types in the above example.
using System;
using System.Collections.Generic;
public class GenericClass
{
List<int> genericList1;
List<string> genericList2;
public GenericClass()
{
genericList1 = new List<int>();
genericList2 = new List<string>();
}
public void AddToList(int item1, string item2)
{
genericList1.Add(item1);
genericList2.Add(item2);
}
public void DisplayList()
{
foreach (var ele in this.genericList1)
{
Console.Write("{0}\t", ele);
}
Console.WriteLine("\n");
foreach (var ele in this.genericList2)
{
Console.Write("{0}\t", ele);
}
}
}
public class Program
{
public static void Main()
{
GenericClass genericObj = new GenericClass();
genericObj.AddToList(28, "Hello");
genericObj.AddToList(999, "Bonjour");
genericObj.AddToList(0, "Ola");
genericObj.AddToList(-123, "Ciao");
genericObj.AddToList(100, "Hallo");
genericObj.DisplayList();
}
}
Generics with Method
Code:
using System;
using System.Collections.Generic;
public class Program
{
public static void Main()
{
int[] intArr = {12, 23, 43, 94, 35};
double[] doubleArr = {12.3, 45.6, 98.7, 1.45, 82.653};
string[] strArr = {"Hello", "Bonjour", "Ola", "Ciao", "Hallo"};
Console.WriteLine("The largest integer in the array is {0}", findMax(intArr));
Console.WriteLine("The largest floating-point number in the array is {0}", findMax(doubleArr));
Console.WriteLine("The largest string in the array is {0}", findMax(strArr));
}
static T findMax<T>(T[] items)
where T : IComparable<T>
{
T max = items[0];
int position = 0;
for (int i = 1; i < items.Length; i++)
{
if (items[i].CompareTo(max) > 0)
{
max = items[i];
position = i;
}
}
return max;
}
}
Output:
The System.Collections.Generic namespace
The System.Collections.Generic namespace in C# contains interfaces and classes defining the generic collections. They allow the programmers to create generic collections that are better in performance and as strongly-types as the non-generic collections.
This namespace contains Lists, Dictionaries, Linked Lists, Hashes, Key-Value Pairs, Stacks, etc, all of which are generic in nature. The programmers can implement them in their code.
Importance of C# Generics
Below is the Importance of C# Generics as follows:
- Generics Allow Code-Reusability: the fundamental principle of good programming. You need not write the same code for each expected data-type. You simply define a type-independent code and tell the compiler that the actual data-type would be provided at the time of code invocation.
- Prevent the Cost of Boxing and Un-Boxing: Of course, the use of generics can be bypassed through object class. The below two pieces of code are equivalent in their tasks.
Generic Code: public T MyFunc(T item);
Non-Generic Code: public object MyFunc(object item)
The object class supersedes all classes and thus the above non-generic code can also be used to generate type-independent code templates.
But, there is a huge performance gap between the two codes. Using the object class incurs an additional cost of boxing and unboxing of the data-types. Generics eliminate this and are thus better in performance.
Conclusion
Thus, we have seen how generics are a must-learn programming feature. This is a highly useful concept, not only in C# but in most modern programming languages.
Further, it is highly recommended to learn about the System.Collections.Generic namespace in C#. Also, to understand the performance of generics, deep dive into how boxing and unboxing have an impact on memory as well as execution time.
Recommended Articles
This is a guide to C# Generics. Here we discuss Importance and How Generics Work in C# along with different examples and code implementation. You can also go through our other suggested articles to learn more –
