C# Online Compiler | .NET Fiddle

// 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; }             
    }

            ContravariantDelegate<string> fun3 = new ContravariantDelegate<string>(Program.Contravariant<string>);
 
// 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. 

Hello World