Generic programming is a powerful tool that C# offers to developers. In this article, we’ll take a look at how generics work in C# and some of the benefits they provide. We’ll also see how to use generics with classes, methods, and delegates. Finally, we’ll look at some of the drawbacks of using generics and ways to work around them.\u00a0<\/p>\n
While we go in-depth in this article with generics, we do have an introductory article on Generics<\/a> if this is a new topic to you.<\/p>\n Let’s start!<\/p>\n In C#, Generics is a concept that makes it possible for programmers to implement classes and methods that defer the specification of their types until the classes and methods are instantiated by the client code.<\/p>\n For example, a generic class might be created for handling customer data, with specific methods for adding, removing, and updating customer records. In this case, the compiler generates the code to handle the type it encounters as we instantiate the class.\u00a0<\/p>\n Generic classes and methods are essential as they make it possible for programmers to enjoy benefits such as reusability, type safety, and efficiency<\/strong>, unlike their non-generic counterparts.\u00a0<\/p>\n This makes them ideal for use with collections and methods which utilize them to implement business logic.\u00a0\u00a0<\/p>\n In C#, the To understand how generics work in C#, we are going to implement some generic classes and methods.<\/p>\n First, let’s start by creating a simple generic class to help us manipulate generic array objects:<\/p>\n Here, we define a generic class In the class, we define a generic type variable We can then proceed to verify that we can generate arrays of different types:<\/p>\n Here, we can see that we can use the Next, let’s create generic methods with type parameters to understand how they work. To keep things simple, let’s write a method to swap elements given two generic type variables:<\/p>\n This method accepts two generic type variables we pass by reference and swaps them by using a We can verify that the We can use generics when we want to utilize delegates<\/a> in C#. We are aware that delegates help us hold references to methods and access them without using their actual names.\u00a0<\/p>\n However, we also know that when we have many methods and need to encapsulate them using delegates, we need to define a delegate for each method. Creating many delegates may end up making our codebases difficult to maintain and reducing application performance.\u00a0<\/p>\n Generic delegates come in handy as we can use the same delegate to hold references to multiple methods.<\/strong> To make this concept easy to understand, let’s define two methods to add and multiply two numbers and an additional method to print the results:<\/p>\n Both Next, we are going to\u00a0define a generic delegate in the Let’s understand how the code works.\u00a0<\/p>\n First, we define a generic delegate In the next step, we create the Finally, to verify that all the methods work as expected, we create two number variables and print the results of both the Addition and Multiplication methods.<\/p>\n After implementing generic classes and methods in our example, we learn that generics enrich our programs in multiple ways.<\/p>\n First, it helps us maximize the principles of code reusability, type safety, and performance.\u00a0<\/p>\n Besides that, the technique allows us to create generic collection classes, which are available in the The technique also helps us define generic interfaces, classes, methods, events, and delegates.<\/p>\n Another way generics enrich our programs is their ability to help us enable access to methods that require specific data types.\u00a0<\/p>\n Finally, the generics help us get information on the types used in a generic data type at compile-time, through the reflection<\/a> technique.<\/p>\n From our examples<\/a>, we can see that we can reuse<\/strong> our code snippets without modifying them thanks to generics. This makes our code base simple to understand and modify when the need arises.\u00a0<\/p>\n Besides reusability, we learn that we benefit from type safety<\/strong> as we need to specify the types of objects we intend to pass to our generic methods and classes. Passing objects of different types to the same generic object results in a compilation error.<\/p>\n Finally, generic types have been known to perform<\/strong> better than their standard type system counterparts since the former types don’t require boxing, unboxing, and type casting.\u00a0<\/p>\n First, we cannot use generics with lightweight dynamic methods as generics are determined at compile time while dynamics are resolved at runtime.<\/p>\n Besides that, we cannot use generic type parameters with enumerations. Generic enumerations can only occur in special circumstances such as nesting it in a generic type.\u00a0<\/p>\n<\/a>What Are Generics in C#?<\/h2>\n
<\/a>Why Use Generics?<\/h2>\n
System.Collections.Generic<\/code> namespace contains generic-based collection classes. However, we can also create generic custom types to implement our generalized solutions and design patterns that enjoy the benefits of type safety<\/strong> and efficiency<\/strong>.\u00a0<\/p>\n<\/a>How Do Generics Work in C#?<\/h2>\n
public class GenericArray<T>\r\n{\r\n private T[] _arrayObj;\r\n\r\n public GenericArray(int size)\r\n {\r\n _arrayObj = new T[size + 1];\r\n }\r\n\r\n public T RetrieveValue(int index)\r\n {\r\n return _arrayObj[index];\r\n }\r\n\r\n public void InsertValue(int index, T value)\r\n {\r\n _arrayObj[index] = value;\r\n }\r\n}<\/pre>\nGenericArray<\/code> of type T<\/code>, which helps us define custom methods to help us manipulate array objects. We denote the generic type as T<\/code> since we use it as a placeholder for the type that the compiler encounters at runtime. However, we need to specify the type when instantiating the generic class.<\/p>\n_arrayObj<\/code> that holds the array values and a constructor to instantiate the class. Next, we define two public methods to insert and retrieve array elements by accepting the index of the array and the generic value as inputs.<\/p>\nvar intArray = new GenericArray<int>(5);\r\nvar guidArray = new GenericArray<Guid>(5);\r\nvar rand = new Random();\r\n\r\nfor (int i = 0; i < 5; i++) \r\n{\r\n intArray.InsertValue(i, rand.Next());\r\n}\r\n\r\nfor (int i = 0; i < 5; i++)\r\n{\r\n guidArray.InsertValue(i, Guid.NewGuid());\r\n}\r\n\r\nAssert.IsInstanceOfType(intArray.RetrieveValue(1), typeof(int));\r\nAssert.IsInstanceOfType(guidArray.RetrieveValue(1), typeof(Guid));<\/pre>\nGenericArray<\/code> class to instantiate array objects of different types, which the compiler determines at runtime. Generics provide compile-time type safety as the solution would not build successfully when we attempt to insert a value of a different type <\/strong>such as a string<\/code> into the intArray<\/code> object.\u00a0<\/p>\n<\/a>Generic Methods<\/h2>\n
public void SwapElements(ref T left, ref T right)\r\n{\r\n T tempVar;\r\n tempVar = left;\r\n left = right;\r\n right = tempVar;\r\n}<\/pre>\ntempVar<\/code> variable to facilitate the swap process.<\/p>\nSwapElements()<\/code> method works with different data types at runtime using this unit test:<\/p>\nvar firstInt = 1;\r\nvar lastInt = 9;\r\nvar firstChar = 'a';\r\nvar lastChar = 'z';\r\nvar integerObj = new GenericMethods<int>();\r\nvar charObj = new GenericMethods<char>();\r\n\r\nintegerObj.SwapElements(ref firstInt, ref lastInt);\r\ncharObj.SwapElements(ref firstChar, ref lastChar);\r\n\r\nAssert.AreEqual(firstInt, 9);\r\nAssert.AreEqual(lastInt, 1);\r\nAssert.AreEqual(firstChar, 'z');\r\nAssert.AreEqual(lastChar, 'a');<\/pre>\n
<\/a>Generic Delegates<\/h2>\n
public int AdditionFunc(int num1, int num2)\r\n{\r\n return num1 + num2;\r\n}\r\n\r\npublic int MultiplicationFunc(int num1, int num2 )\r\n{\r\n return num2 * num1;\r\n}\r\n\r\npublic void PrintString(string stringVal) \r\n{\r\n Console.WriteLine(stringVal);\r\n}<\/pre>\nAdditionFunc<\/code> and MultiplicationFunc<\/code> take two integer values and return their sum and product respectively.<\/p>\nMain()<\/code> method to test these methods:<\/p>\ndelegate T ArithmeticDelegates<T>(T num1, T num2);\r\n\r\nstatic void Main(string[] args)\r\n{\r\n var delegateObj = new GenericDelegates();\r\n var addition = new ArithmeticDelegates<int>(delegateObj.AdditionFunc);\r\n var multiplication = new ArithmeticDelegates<int>(delegateObj.MultiplicationFunc);\r\n\r\n var num1 = 5;\r\n var num2 = 10;\r\n\r\n var printOutput = $\"The sum of {num1} and {num2} is {addition(num1, num2)}\";\r\n delegateObj.PrintString(printOutput);\r\n\r\n printOutput = $\"The multiplication of {num1} and {num2} is {multiplication(num1, num2)}\";\r\n delegateObj.PrintString(printOutput);\r\n}\r\n<\/pre>\nArithmeticDelegates<\/code> that accepts two generic type input parameters and returns one generic output type parameter.<\/p>\ndelegateObj<\/code> object of GenericDelegates<\/code> type and pass the AdditionFunc()<\/code> and MultiplicationFunc()<\/code> methods to our delegate.<\/p>\n<\/a>Features of Generics<\/h2>\n
System.Collections.Generic<\/code> namespace.\u00a0<\/p>\n<\/a>Advantages of Generics<\/h2>\n
<\/a>Disadvantages of Generics<\/h2>\n