Generics and constraints

Without generics, a reusable method either repeats itself per type or falls back to object and loses the type on the way out.

public static object First(object[] items) => items[0];   // loses the type

A type parameter keeps the connection between what went in and what comes out:

public static T First<T>(List<T> items) => items[0];

int n = First(new List<int> { 1, 2, 3 });       // T inferred as int
string s = First(new List<string> { "a", "b" }); // T inferred as string

T is a placeholder the caller fills, almost always without writing it out — the compiler infers it from the argument.

Try it

1public static class Solution2{3    public static (T, T) Swap<T>(T a, T b) => (b, a);4 5    public static string Describe()6    {7        var (a, b) = Swap(1, 2);8        var (x, y) = Swap("left", "right");9        return $"{a},{b} / {x},{y}";10    }11}

Constraints

Inside the method, you may only do what every possible T allows — by default, almost nothing. where narrows what a caller may pass, and in exchange lets the method use it:

public static T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

where T : IComparable<T> says: only types that know how to compare themselves to another instance of themselves may be used here. Without the constraint, a.CompareTo(b) would not compile — the compiler has no way to know an arbitrary T supports it.

Common constraints: where T : class (reference types only), where T : struct (value types only), where T : new() (must have a public parameterless constructor, so the method can create one), and where T : SomeBaseType (must derive from it, or implement it if it is an interface).

Generic classes work the same way

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

var intBox = new Box<int> { Value = 5 };
var stringBox = new Box<string> { Value = "hi" };

List<T> and Dictionary<TKey, TValue> are themselves ordinary generic classes, written with exactly this feature — nothing about them is special-cased into the language.

Common mistakes

1public static class Solution2{3    public static bool AreEqual<T>(T a, T b) => EqualityComparer<T>.Default.Equals(a, b);4 5    public static string Describe()6    {7        int culture = "apple".CompareTo("Banana");8        int ordinal = string.CompareOrdinal("apple", "Banana");9        return $"CompareTo={Math.Sign(culture)} CompareOrdinal={Math.Sign(ordinal)} " +10               $"AreEqual(3,3)={AreEqual(3, 3)} AreEqual(\"a\",\"b\")={AreEqual("a", "b")}";11    }12}

• Assuming string.CompareTo is ordinal. It is culture-aware, using the current culture: it sorts "apple" before "Banana", the way a dictionary would, while string.CompareOrdinal compares character codes and puts the capital B (66) before a (97). A generic Max<T> that calls CompareTo inherits whatever the type's comparison is.
• Writing a == b on an unconstrained T. It does not compile, because the compiler cannot know T has an ==. Use EqualityComparer<T>.Default.Equals(a, b), which uses IEquatable<T> when the type has it.
• Forgetting what default(T) is. It is null for a reference type and zero for a number, so returning default from a generic "find" method cannot tell "not found" from a real 0.

What interviewers ask