界面中的协方差和逆方差

Question

下面是对泛型使用协方差和逆方差的示例

 class Program
    {
        static void Main(string[] args)
        {
            ICovariant<Apple> alCov = new Covariant<Apple>();
            ICovariant<Fruite> fCov = alCov;

            IContravariant<Apple> aContra = new Contravariant<Apple>();
            IContravariant<Apple> fContra = new Contravariant<Fruite>();

        }


        public class Fruite
        {
            public virtual void Print()
            {
                Console.WriteLine("Fruite");
            }
        }

        public class Apple : Fruite
        {
            public override void Print()
            {
                Console.WriteLine("Apple");
            }
        }

        interface IContravariant<in T>
        {
            void Method();

            // This interface can be implicitly cast to MORE DERIVED (downcasting)
            // Usually means T is used as argument
            void Method(T argument);
        }//interface

        interface ICovariant<out T>
        {
            // This interface can be implicitly cast to LESS DERIVED (upcasting)
            // Used for readonly collections
            IEnumerable<T> GetList { get; }
            // Used when T is used as return type
            T Method();
        }//interface


        public class Covariant<T> : ICovariant<T>
        {
            public IEnumerable<T> GetList
            {
                get
                {
                    throw new NotImplementedException();
                }
            }

            public T Method()
            {
                throw new NotImplementedException();
            }
        }
        public class Contravariant<T> : IContravariant<T>
        {
            public void Method()
            {
                Console.Write(typeof(T));
            }

            public void Method(T argument)
            {
                Console.Write(argument);
            }
        }

    }

我理解这些代码行是因为它类似于多态性，并且我理解了它背后的好处。

ICovariant<Apple> alCov = new Covariant<Apple>();
ICovariant<Fruite> fCov = alCov;

但我不理解的是，像下面这几行中的差异带来的好处

IContravariant<Apple> aContra = new Contravariant<Apple>();
IContravariant<Apple> fContra = new Contravariant<Fruite>();

那么，有没有人可以举例说明我如何利用它呢？

Answer 1

so could anyone explain with example of how can I take the benefit of it.

下面是一个使用示例：

 IContravariant<Fruite> fContra = new Contravariant<Fruite>();
 List<IContravariant<Apple>>  contravariants=  new List<IContravariant<Apple>>();
 contravariants.Add(fContra);
 contravariants.Add(aContra);

因此，如果将IContavariant<in T>接口更改为IContavariant<T>，将会出现编译时错误

一个很好的例子是Linq中的Distinct方法，你可以想出一个方法，它做同样的事情，但不使用IEqualityComparer<T>，而是对所有的结果使用相同的算法

在此链接中，您可以找到完整的示例Comparing Generic Collections