C# 返回适当函数以处理参数化类型的参数的泛型方法

我主要想做的是有一个名为

GetHandler

的方法，它返回

Action

。C#语法允许这样做，但老实说，我不知道应该如何实现这样的方法

我想根据T的类型返回不同的函数，因此我当前的尝试如下所示：

    public override Action<T> GetHandler<T>()
    {
        if (typeof(T) == typeof(MyType))
        {
            return delegate (T t)
            {
                var msg = (MyType)t;
                //do stuff
            }
        }
        return null;
    }

public覆盖操作GetHandler（）
{
if（typeof（T）=typeof（MyType））
{
返回委托（T）
{
var msg=（MyType）t；
//做事
}
}
返回null；
}

这不起作用，因为它无法将

t

转换为

MyType

。我也不能返回

委托（MyType msg）

，因为它当然与签名不匹配

在这种情况下，如果C#允许对泛型方法进行多个重写，您可以为单独的输入指定单独的处理程序，然后是一个处理所有其他内容的全面覆盖（catch all override），那将是理想的。但我仍然不知道如何实现“一网打尽”

那么，您建议我如何尽可能接近这个功能呢？在我看来，我的函数几乎什么也做不了，因为T不能转换成任何有用的东西

下面是此机制的一个示例使用：

---

我们有一个类，它有一组实现上述行为的实例。此类有一个方法

SendMessage

。该方法遍历所有包含的实例并对它们调用

GetHandler（）

，检查结果是否为null，如果不是，则向处理程序发送消息。

不确定这是否有帮助，但您是否考虑过仅约束泛型

public override Action<T> GetHandler<T>()
    where T : SomeType // Constrain to some type/interface
{
    // You can treat T like SomeType here
}

public覆盖操作GetHandler（）
其中T:SomeType//约束到某个类型/接口
{
//你不能像这里的人那样对待我
}

---

这样，你至少可以把T看作是某种类型的——也许这就是你想要的？如果没有，你能给出一个用法的例子，这样我就能更好地理解你想要达到的目的吗？

不确定这是否有帮助，但你是否考虑过仅仅限制通用的

public override Action<T> GetHandler<T>()
    where T : SomeType // Constrain to some type/interface
{
    // You can treat T like SomeType here
}

public覆盖操作GetHandler（）
其中T:SomeType//约束到某个类型/接口
{
//你不能像这里的人那样对待我
}

---

这样，你至少可以把T看作是某种类型的——也许这就是你想要的？如果没有，你能给出一个用法的例子，这样我就能更好地理解你想要达到的目的吗？

不确定你需要什么，因为没有给出太多的上下文。但你可以放弃你的出路：

        return delegate (T t)
        {
            var msg = (MyType)(object)t;
            //do stuff
        }

---

双重强制转换关闭编译器。这通常是要避免的。

不确定您需要什么，因为没有给出太多的上下文。但你可以放弃你的出路：

        return delegate (T t)
        {
            var msg = (MyType)(object)t;
            //do stuff
        }

---

双重强制转换关闭编译器。这通常是要避免的。

为什么不做一些类似于：

private void HelloMessageHandler(      HelloMessage      msg ) { ... }
private void GoodByeMessageHandler(    GoodByeMessage    msg ) { ... }
private void HowYaDoingMessageHandler( HowYaDoingMessage msg ) { ... }
.
.
.
public Action<T> GetHandler<T>()
{
  Type t = typeof(T) ;
  Delegate handler ;

  if      ( t == typeof(HelloMessage)      ) handler = (Action<HelloMessage>)      HelloMessageHandler      ;
  else if ( t == typeof(GoodByeMessage)    ) handler = (Action<GoodByeMessage>)    GoodByeMessageHandler    ;
  else if ( t == typeof(HowYaDoingMessage) ) handler = (Action<HowYaDoingMessage>) HowYaDoingMessageHandler ;
  else
  {
    string message =  string.Format( "Unknown Message Type specified: {0}" , t.FullName ) ;
    throw new InvalidOperationException(message);
  }

  Action<T> instance = (Action<T>) handler ;
  return instance ;
}

private void HelloMessageHandler（HelloMessage msg）{…}
私有void GoodByeMessageHandler（GoodByeMessage msg）{…}
私有void HowYaDoingMessageHandler（HowYaDoingMessage msg）{…}
.
.
.
公共操作GetHandler（）
{
类型t=类型（t）；
委托处理程序；
if（t==typeof（HelloMessage））handler=（Action）HelloMessageHandler；
如果（t==typeof（GoodByeMessage））handler=（Action）GoodByeMessageHandler；
else if（t==typeof（HowYaDoingMessage））handler=（Action）HowYaDoingMessageHandler；
其他的
{
string message=string.Format（“指定的未知消息类型：{0}”，t.FullName）；
抛出新的InvalidOperationException（消息）；
}
动作实例=（动作）处理程序；
返回实例；
}

---

对我来说似乎很简单。

你为什么不做一些像：

private void HelloMessageHandler(      HelloMessage      msg ) { ... }
private void GoodByeMessageHandler(    GoodByeMessage    msg ) { ... }
private void HowYaDoingMessageHandler( HowYaDoingMessage msg ) { ... }
.
.
.
public Action<T> GetHandler<T>()
{
  Type t = typeof(T) ;
  Delegate handler ;

  if      ( t == typeof(HelloMessage)      ) handler = (Action<HelloMessage>)      HelloMessageHandler      ;
  else if ( t == typeof(GoodByeMessage)    ) handler = (Action<GoodByeMessage>)    GoodByeMessageHandler    ;
  else if ( t == typeof(HowYaDoingMessage) ) handler = (Action<HowYaDoingMessage>) HowYaDoingMessageHandler ;
  else
  {
    string message =  string.Format( "Unknown Message Type specified: {0}" , t.FullName ) ;
    throw new InvalidOperationException(message);
  }

  Action<T> instance = (Action<T>) handler ;
  return instance ;
}

private void HelloMessageHandler（HelloMessage msg）{…}
私有void GoodByeMessageHandler（GoodByeMessage msg）{…}
私有void HowYaDoingMessageHandler（HowYaDoingMessage msg）{…}
.
.
.
公共操作GetHandler（）
{
类型t=类型（t）；
委托处理程序；
if（t==typeof（HelloMessage））handler=（Action）HelloMessageHandler；
如果（t==typeof（GoodByeMessage））handler=（Action）GoodByeMessageHandler；
else if（t==typeof（HowYaDoingMessage））handler=（Action）HowYaDoingMessageHandler；
其他的
{
string message=string.Format（“指定的未知消息类型：{0}”，t.FullName）；
抛出新的InvalidOperationException（消息）；
}
动作实例=（动作）处理程序；
返回实例；
}

---

对我来说似乎很简单。

你能假设关于

T

的任何事情吗？为什么不让它实现一个接口来公开一些属性或方法，从而以一种通用的方式生成

Func

。如果我开始将T约束为任何形式，那么我最好有一个

GetHandler

，它总是返回与处理该超类相同的函数。您能给出一个用法示例吗？我不太明白这有多有用，所以更多的例子可能有助于找出最佳方法，但您的另一个选择是使用大量的

if

，以及

开关，这使得您对泛型的使用毫无用处。我同意。如果没有更干净的选项，我也可以处理
对象
s…你能假设
t
上有什么吗？为什么不让它实现一个接口来公开一些属性或方法，从而以一种通用的方式生成
Func
。如果我开始将T约束为任何形式，那么我最好使用一个总是返回与j相同的函数的
GetHandler