All 17 Generics questions
More in Generics
Why can't you use operators like + directly on an unconstrained generic T? How do generic type constraints ('where T : ...') restrict what types can be used, and what are the common constraint kinds? How does generic type inference work when calling a generic method, and when do you need to specify the type argument explicitly? What is covariance ('out T') and contravariance ('in T') in generic interfaces, and how does IEnumerable<out T> demonstrate covariance? How are generics implemented for value types vs reference types in the CLR? What problem do generic math / static abstract interface members solve? How would you implement a generic method with MULTIPLE type parameters and constraints that reference EACH OTHER, like a generic mapping function? How do generic type parameters interact with static members, and why does each closed generic type get its OWN independent set of static field values? How would you implement a generic, reusable object pool using generic constraints to ensure poolable objects can be properly reset? How do generic attributes (introduced in C# 11) work, and what limitation did they finally remove compared to older attribute usage patterns?
Advertisement
Back to results for “Generics”
C# › Generics

What are generics in C#, and what specific problems do they solve compared to writing type-specific code?

Intermediate

Answer

Generics let you define a class, method, or interface with a placeholder type parameter (like <T>) that's specified when the type is actually used, avoiding the need to write near-identical code for every different data type -- beyond reducing duplication, generics provide genuine compile-time type safety (the compiler rejects an incompatible type at the call site) and better performance than the older, pre-generics approach of using object and relying on boxing/unboxing or unsafe casts.
// Without generics: separate overloads needed per type
public void Print(int value) => Console.WriteLine(value);
public void Print(string value) => Console.WriteLine(value);

// With generics: one method, any type, still fully type-checked
public void Print<T>(T value) => Console.WriteLine(value);

List<int> numbers = new(); // type-safe: only accepts int, unlike the old non-generic ArrayList
Real-world example A generic Repository<T> base class implements common CRUD operations (Add, GetById, Delete) once, reused across UserRepository, ProductRepository, and every other entity-specific repository in the application without duplicating the same logic per entity type.

Common follow-ups: How do generic constraints (where T : IComparable<T>) restrict what types can be used?;Why do generic collections like List<T> outperform their non-generic predecessors like ArrayList?

Generics;Collections Framework
All 17 Generics questions