C# 实施Co和Contra variance通用接口&；它的实际用途

我试图理解使用变体通用接口（同时使用co和contra variant）的可能用途。有人能解释一下吗？我分别理解了接口的co和contra variance示例

协方差示例

public class Request { }
public class Response { }
public class SuperRequest : Request { }
public class SuperResponse : Response { }

public interface CoVarianceInterface<out O>
{
    O Get();
}

public class CoVarianceInterfaceInstance1 : CoVarianceInterface<Response>
{
    public Response Get()
    {
        Console.WriteLine("Co Variance");

        return null;
    }
}

public class CoVarianceInterfaceInstance2 : CoVarianceInterface<SuperResponse>
{
    public SuperResponse Get()
    {
        Console.WriteLine("Co Variance 1");

        return null;
    }
}

static void CallCoVarianceInterface(CoVarianceInterface<Response> task)
{
    task.Get();
}

static void Test()
{
   CoVarianceInterface<Response> i1 = new CoVarianceInterfaceInstance1();
   CoVarianceInterface<SuperResponse> i2 = new CoVarianceInterfaceInstance2();

   CallCoVarianceInterface(i1);
   CallCoVarianceInterface(i2); **//Co variance here bcoz more derived to less derived type?**
}

public interface ContraVarianceInterface<in O>
{
    void Set(O input);
}

public class ContraVarianceInterfaceInstance1 : ContraVarianceInterface<Request>
{
    public void Set(Request input)
    {
        Console.WriteLine("Contra Variance");
    }
}

public class ContraVarianceInterfaceInstance2 : ContraVarianceInterface<SuperRequest>
{
    public void Set(SuperRequest input)
    {
        Console.WriteLine("Contra Variance 1");
    }
}

static void CallContraVarianceInterface(ContraVarianceInterface<SuperRequest> task)
{
    task.Set(null);
}

static void Test()
{
  ContraVarianceInterface<Request> o1 = new ContraVarianceInterfaceInstance1();
  ContraVarianceInterface<SuperRequest> o2 = new ContraVarianceInterfaceInstance2();

  CallContraVarianceInterface(o1); **//Contra variance here bcoz less derived to more derived type?**
  CallContraVarianceInterface(o2);
}

public interface CoContraInterface<out O, in I>
{
    O Execute(I input);
}

public class CoContraInterfaceInstance1 : CoContraInterface<Response, Request>
{
    public Response Execute(Request input)
    {
        Console.WriteLine("Variance");

        return new Response();
    }
}

public class CoContraInterfaceInstance2 : CoContraInterface<SuperResponse, SuperRequest>
{
    public SuperResponse Execute(SuperRequest input)
    {
        Console.WriteLine("Variance 1");

        return new SuperResponse();
    }
}

static void CallCoContraInterface(CoContraInterface<Request, Response> task)
{
    task.Execute(null);
}

static void Test()
{
   CoContraInterface<Response, Request> c1 = new CoContraInterfaceInstance1();
   CoContraInterface<SuperResponse, SuperRequest> c2 = new CoContraInterfaceInstance2();
   CoContraInterface<Response, SuperRequest> c3 = new CoContraInterfaceInstance1();

   c3 = c1; **//here Request is typed to SuperRequest, so is it contra variance?**
   c3 = c2; **//here Request is typed to SuperRequest, so is it contra variance? also SuperResponse to Response, so is it Co variance as well?**

  CreateSample(c1);
  CreateSample(c2);
  CreateSample(c3);
}


is the above code right? if so where we can practically use an interface that have both Co and Contra variance?

公共类请求{}
公共类响应{}
公共类超级请求：请求{}
公共类超级响应：响应{}
公共接口协方差接口
{
O Get（）；
}
公共类协方差接口实例1:协方差接口
{
公众反应
{
控制台。写入线（“协方差”）；
返回null；
}
}
公共类协方差接口实例2：协方差接口
{
公共超级响应Get（）
{
控制台写入线（“协变项1”）；
返回null；
}
}
静态void调用协方差接口（协方差接口任务）
{
task.Get（）；
}
静态孔隙试验（）
{
协方差接口i1=新的协方差接口实例1（）；
协方差接口i2=新的协方差接口实例2（）；
调用协方差接口（i1）；
CallCovariaceInterface（i2）；**//这里的协方差是从派生更多的类型到派生更少的类型**
}

抵销差异示例

public class Request { }
public class Response { }
public class SuperRequest : Request { }
public class SuperResponse : Response { }

public interface CoVarianceInterface<out O>
{
    O Get();
}

public class CoVarianceInterfaceInstance1 : CoVarianceInterface<Response>
{
    public Response Get()
    {
        Console.WriteLine("Co Variance");

        return null;
    }
}

public class CoVarianceInterfaceInstance2 : CoVarianceInterface<SuperResponse>
{
    public SuperResponse Get()
    {
        Console.WriteLine("Co Variance 1");

        return null;
    }
}

static void CallCoVarianceInterface(CoVarianceInterface<Response> task)
{
    task.Get();
}

static void Test()
{
   CoVarianceInterface<Response> i1 = new CoVarianceInterfaceInstance1();
   CoVarianceInterface<SuperResponse> i2 = new CoVarianceInterfaceInstance2();

   CallCoVarianceInterface(i1);
   CallCoVarianceInterface(i2); **//Co variance here bcoz more derived to less derived type?**
}

public interface ContraVarianceInterface<in O>
{
    void Set(O input);
}

public class ContraVarianceInterfaceInstance1 : ContraVarianceInterface<Request>
{
    public void Set(Request input)
    {
        Console.WriteLine("Contra Variance");
    }
}

public class ContraVarianceInterfaceInstance2 : ContraVarianceInterface<SuperRequest>
{
    public void Set(SuperRequest input)
    {
        Console.WriteLine("Contra Variance 1");
    }
}

static void CallContraVarianceInterface(ContraVarianceInterface<SuperRequest> task)
{
    task.Set(null);
}

static void Test()
{
  ContraVarianceInterface<Request> o1 = new ContraVarianceInterfaceInstance1();
  ContraVarianceInterface<SuperRequest> o2 = new ContraVarianceInterfaceInstance2();

  CallContraVarianceInterface(o1); **//Contra variance here bcoz less derived to more derived type?**
  CallContraVarianceInterface(o2);
}

public interface CoContraInterface<out O, in I>
{
    O Execute(I input);
}

public class CoContraInterfaceInstance1 : CoContraInterface<Response, Request>
{
    public Response Execute(Request input)
    {
        Console.WriteLine("Variance");

        return new Response();
    }
}

public class CoContraInterfaceInstance2 : CoContraInterface<SuperResponse, SuperRequest>
{
    public SuperResponse Execute(SuperRequest input)
    {
        Console.WriteLine("Variance 1");

        return new SuperResponse();
    }
}

static void CallCoContraInterface(CoContraInterface<Request, Response> task)
{
    task.Execute(null);
}

static void Test()
{
   CoContraInterface<Response, Request> c1 = new CoContraInterfaceInstance1();
   CoContraInterface<SuperResponse, SuperRequest> c2 = new CoContraInterfaceInstance2();
   CoContraInterface<Response, SuperRequest> c3 = new CoContraInterfaceInstance1();

   c3 = c1; **//here Request is typed to SuperRequest, so is it contra variance?**
   c3 = c2; **//here Request is typed to SuperRequest, so is it contra variance? also SuperResponse to Response, so is it Co variance as well?**

  CreateSample(c1);
  CreateSample(c2);
  CreateSample(c3);
}


is the above code right? if so where we can practically use an interface that have both Co and Contra variance?

公共接口对变量接口
{
无效集（O输入）；
}
公共类反向变量接口实例1:反向变量接口
{
公共无效集（请求输入）
{
控制台。写线（“对冲差额”）；
}
}
公共类反向变量接口实例2：反向变量接口
{
公共无效集（超级请求输入）
{
控制台写入线（“抵销差额1”）；
}
}
静态void CallContraVarianceInterface（ContraVarianceInterface任务）
{
task.Set（空）；
}
静态孔隙试验（）
{
ContraVarianceInterface o1=新的ContraVarianceInterfaceInstance1（）；
ContraVarianceInterface o2=新的ContraVarianceInterfaceInstance2（）；
CallContrarVarianceInterface（o1）；**//此处的反向差异是从派生较少的类型转换为派生较多的类型吗**
呼叫逆变接口（o2）；
}

协方差/抵销方差

public class Request { }
public class Response { }
public class SuperRequest : Request { }
public class SuperResponse : Response { }

public interface CoVarianceInterface<out O>
{
    O Get();
}

public class CoVarianceInterfaceInstance1 : CoVarianceInterface<Response>
{
    public Response Get()
    {
        Console.WriteLine("Co Variance");

        return null;
    }
}

public class CoVarianceInterfaceInstance2 : CoVarianceInterface<SuperResponse>
{
    public SuperResponse Get()
    {
        Console.WriteLine("Co Variance 1");

        return null;
    }
}

static void CallCoVarianceInterface(CoVarianceInterface<Response> task)
{
    task.Get();
}

static void Test()
{
   CoVarianceInterface<Response> i1 = new CoVarianceInterfaceInstance1();
   CoVarianceInterface<SuperResponse> i2 = new CoVarianceInterfaceInstance2();

   CallCoVarianceInterface(i1);
   CallCoVarianceInterface(i2); **//Co variance here bcoz more derived to less derived type?**
}

public interface ContraVarianceInterface<in O>
{
    void Set(O input);
}

public class ContraVarianceInterfaceInstance1 : ContraVarianceInterface<Request>
{
    public void Set(Request input)
    {
        Console.WriteLine("Contra Variance");
    }
}

public class ContraVarianceInterfaceInstance2 : ContraVarianceInterface<SuperRequest>
{
    public void Set(SuperRequest input)
    {
        Console.WriteLine("Contra Variance 1");
    }
}

static void CallContraVarianceInterface(ContraVarianceInterface<SuperRequest> task)
{
    task.Set(null);
}

static void Test()
{
  ContraVarianceInterface<Request> o1 = new ContraVarianceInterfaceInstance1();
  ContraVarianceInterface<SuperRequest> o2 = new ContraVarianceInterfaceInstance2();

  CallContraVarianceInterface(o1); **//Contra variance here bcoz less derived to more derived type?**
  CallContraVarianceInterface(o2);
}

public interface CoContraInterface<out O, in I>
{
    O Execute(I input);
}

public class CoContraInterfaceInstance1 : CoContraInterface<Response, Request>
{
    public Response Execute(Request input)
    {
        Console.WriteLine("Variance");

        return new Response();
    }
}

public class CoContraInterfaceInstance2 : CoContraInterface<SuperResponse, SuperRequest>
{
    public SuperResponse Execute(SuperRequest input)
    {
        Console.WriteLine("Variance 1");

        return new SuperResponse();
    }
}

static void CallCoContraInterface(CoContraInterface<Request, Response> task)
{
    task.Execute(null);
}

static void Test()
{
   CoContraInterface<Response, Request> c1 = new CoContraInterfaceInstance1();
   CoContraInterface<SuperResponse, SuperRequest> c2 = new CoContraInterfaceInstance2();
   CoContraInterface<Response, SuperRequest> c3 = new CoContraInterfaceInstance1();

   c3 = c1; **//here Request is typed to SuperRequest, so is it contra variance?**
   c3 = c2; **//here Request is typed to SuperRequest, so is it contra variance? also SuperResponse to Response, so is it Co variance as well?**

  CreateSample(c1);
  CreateSample(c2);
  CreateSample(c3);
}


is the above code right? if so where we can practically use an interface that have both Co and Contra variance?

公共接口协同控制器界面
{
O执行（I输入）；
}
公共类CoContractorFaceInstance1:CoContractorFace
{
公共响应执行（请求输入）
{
控制台。写入线（“变更”）；
返回新的响应（）；
}
}
公共类CoContractorFace实例2：CoContractorFace
{
公共超级响应执行（超级请求输入）
{
控制台写入线（“变更1”）；
返回新的超级响应（）；
}
}
静态无效CallCoContraInterface（CoContraInterface任务）
{
task.Execute（null）；
}
静态孔隙试验（）
{
CoContracterFace c1=新的CoContracterFaceInstance1（）；
CoContracterFace c2=新的CoContracterFaceInstance2（）；
CoContracterFace c3=新的CoContracterFaceInstance1（）；
c3=c1；**//这里的请求被键入SuperRequest，所以是相反的吗**
c3=c2；**//这里的请求被键入SuperRequest，那么它是相反的吗？也是SuperResponse到Response，那么它也是协变的吗**
创建样本（c1）；
创建样本（c2）；
创建样本（c3）；
}
上述代码正确吗？如果是这样的话，我们在哪里可以实际使用一个既有协方差又有逆变方差的接口？

---

谢谢

看看这里：

如果你没有用前导的

I

来命名你的接口，那么它就不惯用，而且有点混乱。