Please enable JavaScript.

Coggle requires JavaScript to display documents.

GENERICS - Coggle Diagram

GENERICS

Create a generic

public class GenericList<T>
{
    public void Add(T number)
    {
        throw new NotImplementedException();
    }

    public T this[int index]
    {
        get { throw new NotImplementedException(); }
    }
}

Usage

        var books = new GenericList<Book>();
        books.Add(book);

        var numbers = new GenericList<int>();
        numbers.Add(1);

Multiple parameters generics

Usage

        var dict = new GenericDictionary<string, Book>();

public class GenericDictionary<TKey, TValue>
{
    public void Add(TKey key, TValue value)
    { }
}

Constrains

Without constrains a generic class will accept any type
Sometime we want to limit what is being sent as a parameter to a generic class

public class Utilities
{
    public int Max(int a, int b)
    {
        return a > b ? a : b;
    }

    // Generic Method
    public T Max<T>(T a, T b)
    {
        return a > b ? a : b;
    }
}

The generic method will not work
Because the compiler doesn't know the type of T, it will not apply comparison between A and B
At this points it thinks that A and B are objects

Solution

We need to apply a constrain at the end of the method and give at the compiler more informations
By adding the IComparable interface we tell the compiler that the object we will pass as a parameter will be comparable

 public class Utilities
{
    public int Max(int a, int b)
    {
        return a > b ? a : b;
    }

    // Generic Method
    public T Max<T>(T a, T b) where T : IComparable
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

public class Utilities<T> where T : IComparable
{
    public int Max(int a, int b)
    {
        return a > b ? a : b;
    }

    // Generic Method
    public T Max(T a, T b)
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}

TYPES OF CONSTRAINS

where T : IComparable
--- #

where T : Product

where T : struct

where T : class

where T : new()

public class Utilities<T> where T : IComparable, new()
{
    public void DoSomething(T value)
    {
        var obje = new T();
    }
}

public class DiscountCalculator<TProduct> where TProduct : Product
{
    public int CalculateDiscount(TProduct product)
    {
        return product.Price;
    }
}