// Author   : Tech Point Fundamentals

// Website  : www.techpointfunda.com

// YouTube  : https://www.youtube.com/c/TechPointFundamentals

// Demo     : Covariant and Contravariant in C# 

​

using System;

using System.Collections.Generic;

using System.Linq;

​

​

interface ICovariant<out T>

{

    // T as input parameter not allowed

    //void Add(T item);

    //void Update(T item);

    void Delete(int id);

    T Get(int id);

    IEnumerable<T> GetAll();

    IQueryable<T> iGetAll();

​

    // But T is allowed in Action<T> because it is a ContraVariant Delegate 

    void Acknowledge(Action<T> callback); 

​

    // Generic constraint for the interface methods not allowed. 

    //void DoSomething<T2>() where T2 : T; 

}

​

interface IContravariant<in T>

{

    void Add(T item);

    void Update(T item);

    void Delete(int id);

    // T as output type parameter not allowed

    //T Get(int id);

    //IEnumerable<T> GetAll();

​

    // Generic constraint for the interface methods are allowed in contravariant or invariant types  

    void DoSomething<T2>() where T2 : T;

}

​

interface IVariant<in Tin, out Tout>

{

        void Add(Tin item);

        void Update(Tin item);

        void Delete(int id);

        Tout Get(int id);

        IEnumerable<Tout> GetAll();

}

​

interface IDerivedVariant<Tin, Tout> : IVariant<Tin, Tout>

{

        void PUT(Tin item);

        void Patch(Tin item);

        Tout Details(int id);

}

​

// covariant delegate: T cannot be input parameter

public delegate T CovariantDelegate<out T>(double num);

​

// contravariant delegate: T can not be return type

public delegate void ContravariantDelegate<in T>(T obj);

​

// Variant delegate: Have both IN and OUT type

public delegate Tout VariantDelegate<in Tin, out Tout>(Tin obj);

​

public class Program

{

    public static void Main()

    {   

            /* Covariant */

            Console.WriteLine("\n\n************** COVARIANT IEnumerable<T> ********************");

            IEnumerable<string> strings = new List<string>() { "www.techpointfunda.com", "Tech Point Fundamentals" };

            IEnumerable<object> objects = strings;

​

            foreach (var item in objects)

            {

                Console.WriteLine(item);

            }   

            /* Contravariant */

            Console.WriteLine("\n\n************** CONTRAVARIANT IComparer<T> ********************");

            Father f1 = new Father() { Id = 1, Name = "Tech Point Fundamentals" };

            Father f2 = new Father() { Id = 1, Name = "Tech Point Fundamentals" };

​

            IComparer<Father> Fcomparer = new Comparer();

​

            if (Fcomparer.Compare(f1, f2) == 0)

                Console.WriteLine("Both Objects are equal");

            else

                Console.WriteLine("Both Objects are not equal");

            /* Variant Delegate */

            Console.WriteLine("\n\n************** VARIANT DELEGATES ********************");

            CovariantDelegate<string> fun = new CovariantDelegate<string>(Program.Covariant<string>);

            Console.WriteLine(fun(10.5));           

            CovariantDelegate<Int32> fun2 = (double num) => Convert.ToInt32(num);

            Console.WriteLine(fun(20.5));

​

​

            ContravariantDelegate<string> fun3 = new ContravariantDelegate<string>(Program.Contravariant<string>);

            fun3("Tech Point Fundamentals");

​

            ContravariantDelegate<string> fun4 = (string str) => Console.WriteLine(str);

            fun4("www.techpointfunda.com");  

            /* Covariance in Array */

            Console.WriteLine("\n\n************** COVARIANT ARRAY ********************");

             object[] arrayRefType = new String[5];

​

            arrayRefType[0] = "www.techpointfunda.com";

            arrayRefType[1] = "Tech Point Fundamentals";

​

            // Cause Runtime Exception here

            //rayRefType[2] = 5;

            foreach (var item in arrayRefType)

            {

               Console.WriteLine(item);

            }

    }

    static T Covariant<T>(double number)

    {

        return (T)Convert.ChangeType(number, typeof(T));

    }

​

    static void Contravariant<T>(T input)

    {

        Console.WriteLine(input);

    }   

}

​

public class Comparer : IComparer<GrandFather> 

{

        public int Compare(GrandFather x, GrandFather y)

        {

            return string.CompareOrdinal(x.Name, y.Name);

        }                

}

​

    public class GrandFather : Object

    {

        public int Id { get; set; }

        public string Name { get; set; }      

    }

    public class Father: GrandFather

    {

        public int Age { get; set; }

        public string City { get; set; }             

    }