C# 如何强制转换泛型参数？

以下是我想写的：

public void Foo<T>(T parameter) {
  otherObject.Bar<T>(parameter);
}

public void Foo（T参数）{
otherObject.Bar（参数）；
}

Bar（）方法的签名为：

public void Bar<T>(T parameter) where T: class 

公共空栏（T参数），其中T:class

所以我得到了一个编译错误，因为Foo签名中的T没有相同的约束。不幸的是，我不会写：

public void Foo<T>(T parameter) where T: class {
  otherObject.Bar<T>(parameter);
}

public void Foo（T参数），其中T:class{
otherObject.Bar（参数）；
}

因为Foo正在实现一个在外部接口中定义的方法。问题是:

在调用Bar之前，我是否可以在方法Foo中转置T。（注意，我可以肯定T总是一个类——我只需要通过编译器）

我发现的唯一方法是使用反射，但我想知道我是否缺少一个更简单的技巧。

您可以这样使用：

public void Foo<T>(T parameter)
{
    dynamic p = parameter

    otherObject.Bar(p);
}

public void Foo（T参数）
{
动态p=参数
其他对象。Bar（p）；
}

正在发生的情况是，对

otherObject.Bar

的调用的解析是在运行时进行的，因为其中一个参数的类型为

dynamic

。假设

T

是参考类型，则解析将成功

诚然，这最终使用了反射（正如您所指出的），但是语法可能比您使用的更好

当然，如果

T

不是一个类，这将给您一个运行时错误。

public void Foo（T参数）
{
otherObject.Bar（参数）；
}

如果您是otherObject.Bar的所有者，是否可以删除类约束？这种方法的优点。或者创建一个没有约束的新的类似方法

卡斯佩林。我不确定您的答案是否正确，因为您的Foo方法上有类约束。问题指出这是不可能的，因为Foo是一个外部接口的实现。例如，下面的代码不起作用

public void Foo<T>(T param)
    {
        dynamic xx = param;

        this.Bar(param);
    }

    private void Bar<T>(T param) where T: class {

    }

public void Foo（T参数）
{
动态xx=参数；
这个.Bar（param）；
}
私有无效条（T参数），其中T:class{
}

---

并显示为一个错误。

下面是对casperOne答案的一个稍微不同的理解，使用隐式接口实现：

public void Foo<T>(T parameter) where T: class {
    otherObject.Bar<T>(parameter);
}

void IFoo.Foo<T>(T parameter){
    Foo((dynamic)parameter);
}

public void Foo（T参数），其中T:class{
otherObject.Bar（参数）；
}
void IFoo.Foo（T参数）{
Foo（（动态）参数）；
}

---

这允许您在编译时将约束包含在任何知道调用什么特定对象类型的对象上，同时仍然允许您实现

IFoo

接口。

Nope；没有别的办法了。Foo方法类的签名是什么？+1我要说的。虽然我不太明白它为什么会起作用，因为从技术上讲，值类型也可以转换为

对象

@mellamokb值类型不转换为

对象

，它们是装箱的。@casperOne:如果是这样的话，那么结构/类区别的第一点是什么（就泛型而言）？@mellamokb它在那里，因此您可以对类型参数

T

执行操作，例如与null的比较等。如果您框选值类型，则框选的值是

对象

，你可以在

对象上执行你想要的任何引用类型操作。这将显示为一个错误，因为你没有将
xx
传递到
条
，你仍然从
Foo
传递
param
。谢谢-是的，你的代码比我的反射解决方案更小/更整洁，它是：otherObject.GetType（）.GetMethod（“Bar”）.MakeGenericMethod（typeof（T））.Invoke（otherObject，新对象[]{parameter}）；
public void Foo<T>(T parameter) where T: class {
    otherObject.Bar<T>(parameter);
}

void IFoo.Foo<T>(T parameter){
    Foo((dynamic)parameter);
}