C# Generics

Without generics, a container intended for many kinds of values could store object. Callers would need casts to retrieve specific values, and a mistaken mixture might fail only at runtime. Another approach would duplicate IntBox, StringBox, and CustomerBox even though their behavior is identical.

A generic design leaves a type-shaped blank and lets the caller fill it. In List<string>, T becomes string throughout that list instance. In Dictionary<string, decimal>, TKey becomes string and TValue becomes decimal. The compiler then preserves the same safety as a handwritten single-type version.

First<T> declares T after its name and uses T for the array elements and return value. When called with int[], the compiler infers T as int. The same implementation works for strings without converting either result from object.

A generic algorithm can only use operations known to be valid for every possible T. It can assign, compare with null in appropriate contexts, or call object members, but it cannot assume T has a Price property or + operator without a suitable design.

static void Swap<T>(ref T left, ref T right)
{
  T temporary = left;
  left = right;
  right = temporary;
}

A generic class can retain values of T across methods. The Box<T> below wraps one value and describes it without knowing the eventual type. Real examples include collections, task results, nullable values, and result wrappers.

Do not make a type generic simply to appear flexible. If the domain concept only makes sense for Money, using T shifts useful constraints onto callers. Generic parameters should represent a real family of types that share the same algorithm or structure.

class Box<T>
{
  public T Value { get; }

  public Box(T value)
  {
      Value = value;
  }

  public string Describe()
  {
      return $"Box contains: {Value}";
  }
}

A where constraint narrows which types may be supplied and gives the generic implementation additional guarantees. where T : class requires a reference type; where T : new() requires an accessible parameterless constructor; where T : ISomeInterface requires a capability.

Use the weakest constraint that supports the operation. An interface constraint is often better than a concrete base class because it asks only for the behavior the algorithm needs. If a generic method accumulates many constraints and type checks, separate designs may be clearer.

interface IHasName
{
  string Name { get; }
}

static void PrintName<T>(T item) where T : IHasName
{
  Console.WriteLine(item.Name);
}