C# Generics – Generic Classes, Methods, and Constraints

Introduction – Why Use Generics in C#

Generics in C# allow you to write flexible, reusable, and type-safe code. Instead of writing the same logic multiple times for different data types, generics let you define a method, class, or interface with placeholders for the data types it operates on.

In this guide, you’ll learn:

• What generics are and how they work
• How to create generic classes and methods
• Benefits of generics over non-generic code
• Real-world examples and best practices

Core Concept – What Are Generics?

Generics enable type parameters in classes, methods, interfaces, delegates, and more. They help you avoid redundancy and runtime casting by enforcing compile-time type checking.

Example:

List<int> numbers = new List<int>();

The List<T> is a generic class where T is replaced with int.

Generic Class – Basic Example

public class Box<T>
{
    public T Value;

    public void Display()
    {
        Console.WriteLine($"Value: {Value}");
    }
}

Usage:

Box<string> nameBox = new Box<string>();
nameBox.Value = "Alice";
nameBox.Display();  // Output: Value: Alice

Generic Method Example

public static void Swap<T>(ref T a, ref T b)
{
    T temp = a;
    a = b;
    b = temp;
}

Usage:

int x = 5, y = 10;
Swap(ref x, ref y);
Console.WriteLine($"{x}, {y}");  // Output: 10, 5

Generic Constraints

You can restrict generic types using constraints to ensure they meet specific requirements.

public class Repository<T> where T : class
{
    public void Save(T item)
    {
        // save logic
    }
}

Tips, Pitfalls & Best Practices

Tip: Use generics to avoid repeated code blocks for multiple types.

Pitfall: You can’t use T with operators like +, - unless constrained with a specific interface or logic.

Best Practice: Use descriptive type names (TKey, TValue, TItem) in generic classes for clarity.

Use Cases of Generics

• Collections: List<T>, Dictionary<TKey, TValue>
• Repositories: Generic repositories in data access
• Utilities: Swap, Compare, Sort, etc.
• Dependency Injection: Generic services and interfaces

Summary – Recap & Next Steps

C# Generics let you build scalable and type-safe code. They’re foundational to .NET collections, reusable components, and clean architecture.

Key Takeaways:

• Generics reduce code duplication and casting
• Use <T> to define flexible methods and classes
• Apply constraints for safer, more predictable behavior

Up next: Explore C# Regular Expressions to master pattern matching in strings.

FAQ – C# Generics

What is the purpose of generics in C#?
To write reusable and type-safe code that works with any data type.

Can I use multiple type parameters in generics?
Yes, e.g., Dictionary<TKey, TValue>.

Do generics improve performance?
Yes. They avoid boxing/unboxing and reduce runtime casting.

Can I create a generic interface or delegate?
Absolutely. Generics work with interfaces and delegates too.

What are generic constraints?
They restrict the type arguments that can be used (e.g., where T : class).