Generics reprezinta un mecanism care permite reutilizarea codului, sporind productivitatea programatorilor.
C# si CLR permit crearea interfetelor generice. Presupunem ca avem nevoie de o interfata care specifica un anumit comportament pentru un tip specificat de programator.

    //declararea unei interfete generice
    public interface IMyGeneric<T>
    {
        T Id { get; }
    }

    //implementarea interfetei generice pentru un tip specificat
    class MyIntClass : IMyGeneric<int>
    {
        private int _id;
        #region IMyGeneric<int> Members

        public int Id
        {
            get { return _id; }
        }

        #endregion
    }

    class MyStringClass : IMyGeneric<string>
    {
        private string _id;

        #region IMyGeneric<string> Members

        public string Id
        {
            get { return _id; }
        }

        #endregion
    }

Unele interfete definesc metode care au parametri/tip returnat Object. La apelarea acestor interfete, orice instanta al oricarui tip poate fi transmisa. Daca este tip valoare, va avea loc boxing. Exemplu in MyFirstMethod. In MySecondMethod fenomenul de boxing este eliminat, iar metoda devine strongly-type.

        static void MyFirstMethod()
        {
            int a = 0, b = 2;
            string c = "3";
            IComparable d = a;
            
            //este permisa transmiterea unei valoari de tip int
            d.CompareTo(b);
            //este permisa transmiterea unei valori de tip string, 
            //dar la runtime va fi aruncata o exceptie de tip ArgumentException
            d.CompareTo(c);
        }

        static void MySecondMethod()
        {
            int a = 0, b = 1;
            string c = "3";
            IComparable<int> d = a;
           
            //este permisa transmiterea unei valori de tip int
            d.CompareTo(b);
            //eroare la compilare, metoda interfetei este strongly typed
            d.CompareTo(c);
        }

BCL contine atat interfete generice cat si non-generice. Acestea din urma exista pentru a asigura backward compatibility.
O clasa poate implementa aceeasi interfata generica, atat timp cat tipul este diferit.

    public class MyClass : IComparable<int>, IComparable<string>
    {
        private int myVal = 1;

        #region IComparable<int> Members

        public int CompareTo(int other)
        {
            return myVal.CompareTo(other);
        }

        #endregion

        #region IComparable<string> Members

        public int CompareTo(string other)
        {
            return myVal.CompareTo(Int32.Parse(other));
        }

        #endregion
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass m = new MyClass();
            Console.WriteLine(m.CompareTo(4));
            Console.WriteLine(m.CompareTo("4"));
            Console.Read();
        }
    }