Generics are a way to create reusable and flexible code by allowing you to define a class, method, or data structure without specifying the exact type it will work with until it's used.
Generics introduce type parameters, which act like placeholders for the actual data types you specify later.
Generic Class
public class Box<T>
{
private T _item;
public void Add(T item)
{
_item = item;
}
public T Get()
{
return _item;
}
}
--- Calling a generic class
Box<int> intBox = new Box<int>();
intBox.Add(42);
Console.WriteLine($"Int value: {intBox.Get()}");
Box<string> stringBox = new Box<string>();
stringBox.Add("Hello Generics!");
Console.WriteLine($"String value: {stringBox.Get()}");
Generic Method
public static void PrintValues<T>(T a, T b)
{
Console.WriteLine($"Value 1: {a}, Value 2: {b}");
}
// Usage
PrintValues(10, 20); // Output: Value 1: 10, Value 2: 20
we can use reference type also with generics
public static void Swap<T>(ref T a, ref T b)
{
T temp = a;
a = b;
b = temp;
}
// Usage
int x = 10, y = 20;
Swap(ref x, ref y); // Now x = 20, y = 10
Generic Constraints
A generic constraint in C# is a way to specify the requirements that a type parameter (T) must meet for it to be used in a generic class, method, or delegate. By default, type parameters in generics can represent any type. Constraints allow you to narrow this down, ensuring the type parameter meets specific criteria.
Syntax
public class MyClass<T> where T : constraint
{
// Class implementation
}
Example
where T : struct (Value Type Constraint)
Restricts T to value types like int, float, bool, etc.
We cannot directly assign the dateType in the contraint.(for eg . where T:int)
public class ValueContainer<T> where T : struct
{
public T Value { get; set; }
}
// Usage
ValueContainer<int> intContainer = new ValueContainer<int>();
// ValueContainer<string> stringContainer; // Compilation error
where T : class (Reference Type Constraint)
Restricts T to reference types like string, classes, or interfaces.
public class ReferenceContainer<T> where T : class
{
public T Value { get; set; }
}
// Usage
ReferenceContainer<string> stringContainer = new ReferenceContainer<string>();
// ReferenceContainer<int> intContainer; // Compilation error
You can combine multiple constraints using a comma-separated list.
public class MultiConstraint<T> where T : class, new()
{
public T CreateInstance()
{
return new T();
}
}
Top comments (0)