C# 编译时泛型语法 类GenericWrapper { } 类包装器实例：GenericWrapper { } 类用法 { 公共静态用法创建（T2），其中T1:GenericWrapper { 返回null； } } ... //工作 用法。创建（“条”）； //不起作用 用法。创建（“条”）；

我怀疑答案是否定的，但有没有办法让最后一行编译

我希望编译器强制我提供一个字符串参数，而不必知道或先检查

WrapperInstance

以查看

GenericWrapper

的

T

实现了什么

我知道我可以通过使用第一个方法或将

object

作为参数并进行运行时检查来编译它，但这不是问题所在；）我怀疑这是我唯一的两个选择

谢谢

我怀疑答案是否定的，但有没有办法让最后一行编译

---

否。

Create

有两个泛型类型参数。可以不指定，也可以同时指定。如果没有，编译器将尝试从调用参数推断类型。但是，在这种情况下不能，因为

T1

从未出现在参数列表中。因此，您必须同时指定这两者。

这里有两个问题：

• 您只需要推断一个类型参数，然后指定另一个类型参数。使用普通类型推断无法做到这一点。但是，您可以将

  用法设置为泛型，从而在此处指定一个类型参数，并使用泛型方法推断另一个类型参数：
  
  class GenericWrapper<T>
  {   
  }
  
  class WrapperInstance : GenericWrapper<string>
  {   
  }
  
  class Usage
  {
      public static Usage Create<T1, T2> (T2 t2) where T1 : GenericWrapper<T2>
      {
          return null;
      }
  }
  
  ...
  
  // works
  Usage.Create<WrapperInstance, string>("bar");
  
  // doesnt work
  Usage.Create<WrapperInstance>("bar");
  
  Usage.Create（“foo”）；
  
  这是我以前经常做的事情，但这只会导致第二个问题
  

• 要指定的类型参数（T1）受要推断的类型参数（T2）的约束。上面的示例无法做到这一点，因为

  用法

  没有要验证的T2。。。而且，不能将现有类型参数约束在泛型方法上，只能约束在方法中引入的类型参数

我认为有一种方法可以做到这一点：

公共类用法
{
公共静态使用（T2）
{
返回新用法（t2）；
}
}
公共类用法
{
private readonly T2；//假设我们需要它
公共用途（T2）
{
这1.t2=t2；
}
//我不知道你到底想要什么样的退货
公共静态Foo Create（），其中T1:GenericWrapper
{
//随便
}
}

您可以这样使用它：

public class Usage
{
    public static Usage<T2> For<T2>(T2 t2)
    {
        return new Usage<T2>(t2);
    }
}

public class Usage<T2>
{
    private readonly T2 t2; // Assuming we need it

    public Usage(T2 t2)
    {
        this.t2 = t2;
    }

    // I don't know what return type you really want here
    public static Foo Create<T1>() where T1 : GenericWrapper<T2>
    {
        // Whatever
    }
}

Usage.Foo（“bar”）.Create（）；

我不知道你想做些什么，但我不知道这是否有帮助，但它确实在以下方面实现了你的目标：

• 正在验证

  WrapperInstance

  类型参数
• 推断

  字符串

  类型参数

---

检查另一个问题：由于C#的限制，它将无法工作。但是，如果你告诉更多关于你想要归档的内容，也许有更好的方法把它写下来我相信没有必要再解释更多的原因。请看我在问题中的评论，这是一个关于几乎相同事情的长时间讨论：）嗯，谢谢，这是一个有趣的方法。我希望能够指定T1，然后在不必“知道”T2是什么的情况下提示输入T2的实例（即不必知道T1在T1:X的情况下扩展了什么）@Andrew：不幸的是，你不能这样做，因为T1受T2的约束，而不是相反。

public class Usage
{
    public static Usage<T2> For<T2>(T2 t2)
    {
        return new Usage<T2>(t2);
    }
}

public class Usage<T2>
{
    private readonly T2 t2; // Assuming we need it

    public Usage(T2 t2)
    {
        this.t2 = t2;
    }

    // I don't know what return type you really want here
    public static Foo Create<T1>() where T1 : GenericWrapper<T2>
    {
        // Whatever
    }
}

Usage.Foo("bar").Create<WrapperInstance>();