C# Generics

Generic Class in C#

A generic class in C# is a class that can function with multiple data types. When creating an instance of the class, you can specify the actual data type using angle brackets <T> or other type parameters. Generic classes allow you to write code that is more flexible, reusable, and type-safe because it can handle a wide range of data types without compromising safety or performance.

Example:

Code:

Output:

Explanation:

In the above code, we define a generic class MyGenericClass<T> that takes a type parameter T. This parameter T can represent any data type. Inside the class, we have a private field value of type T.

In the Main method, we create two instances of MyGenericClass: intGeneric with an integer type (int) and stringGeneric with a string type (string). We pass the respective values to the constructor.

The GetValue() method returns the value stored in the value field. When we call intGeneric.GetValue(), it returns the integer value 42, and when we call stringGeneric.GetValue(), it returns the string value "Hello, Generics!".

Instantiating Generic Class

Instantiating a generic class in C# involves creating an object of the generic class with specific data types provided for the type parameters. By providing the required data types inside angle brackets during instantiation, developers create instances that are tailored to handle those specific data types. This enables the generic class to operate with different data types without sacrificing type safety.

Example:

Suppose we have a simple generic class called MyGenericClass<T> that takes a type parameter T:

To instantiate this generic class with a specific data type, you can provide the type argument in angle brackets when creating an instance:

In this example, we created two instances of the MyGenericClass, one with an integer-type argument and the other with a string-type argument. The type parameter T is replaced with the specified data type (int and string) during instantiation, making it a type-specific instance of the generic class. The GetData() method then returns the data stored in the instance.

Generic Fields

Generic fields in C# are classes that have fields specified inside of them that can handle various data types. A type parameter enclosed in angle brackets <T> is used to construct a generic class, allowing you to utilize this type parameter as the data type for fields inside the class. This makes it possible for you to design reusable classes that are adaptable to different data types without duplicating the class's implementation.

Example:

C# code example that demonstrates a generic class with a generic field:

In this example, we have a generic class Box <T> with a single generic field called content. We create two instances of this class, one with an integer type and another with a char type. The GetContent() method retrieves the data stored in the generic field for each instance.

Output:

Generic Methods

In C#, a generic method allows developers to create versatile functions capable of working with multiple data types. These methods adapt to various input types using type parameters (e.g., T), eliminating the need for method overloads. When calling a generic method, the type argument provided replaces the type parameter, enabling the method to handle specific data types. Generic methods provide compile-time type safety, ensuring that only compatible data types can be used.

Example:

Output:

In the above example, we have a generic class GenericMethods with a generic method called DisplayArray.The DisplayArray method takes an array of any data type T and prints its elements.

In the Main method, we demonstrate using the DisplayArray method with both an integer array and a string array. The method provides a simple and consistent way to print the elements of different types of arrays.

Features of C# Generics

The use of generics can enhance your programs in the following ways:

• Code Reuse, Performance, and Type Safety:
  They improve your code by enabling code reuse, ensuring performance, and providing type safety.
• Custom Generic Components:
  You can create your generic classes, methods, interfaces, and delegates to build flexible components.
• Generic Collection Classes:
  The .NET framework includes various generic collection classes in the System.Collections.Generic namespace. These collections offer better performance compared to non-generic collections, as they avoid boxing and unboxing operations.
• Type Information at Runtime:
  Generics allow you to get information about the types used in generic data types at runtime using reflection and type inference.

Advantages of Generics in C#

• Type Safety:
  Generics ensure that data types are enforced at compile-time, reducing runtime errors and providing enhanced type safety.
• Collections:
  Generics are heavily used in collections like List<T>, Dictionary<T, U>, and more, providing type-safe and efficient data structures.
• Framework Integration:
  Generics are widely used in .NET Framework classes, allowing seamless integration with existing APIs.
• Code Performance and Type Checking:
  Generics avoid the performance overhead of casting and the need for runtime type checks, improving execution speed.