Question

我使用以下方法：

public void M1(Int32 a)
{
  // acquire MyMutex
  DoSomething(a);
  // release MyMutex
}

和

public void M2(String s, String t)
{
  // acquire MyMutex
  DoSomethingElse(s, t);
  // release MyMutex
}

从目前为止我发现，似乎不可能对具有不同签名的两种方法使用单个委托。

还有其他选择来写这样的东西：

public void UsingMutex(...)
{
  // acquire MyMutex
  ...
  // release MyMutex
}

UsingMutex(M1);
UsingMutex(M2);

目前我所能想到的是使用两个委托和一个布尔标志来知道要调用哪个委托，但这不是一个长期的解决方案。

可以将泛型与代理结合起来吗？如果是这样，您是否有任何类型文档的链接？

环境：C＃2.0

Answer 1

绝对可以将代表与泛型混合使用。在2.0中，Predicate<T>等是很好的例子，但你必须拥有相同数量的args。在这种情况下，也许一个选项是使用捕获来在委托中包含args？

即

    public delegate void Action();
    static void Main()
    {
        DoStuff(delegate {Foo(5);});
        DoStuff(delegate {Bar("abc","def");});
    }
    static void DoStuff(Action action)
    {
        action();
    }
    static void Foo(int i)
    {
        Console.WriteLine(i);
    }
    static void Bar(string s, string t)
    {
        Console.WriteLine(s+t);
    }

请注意，Action是在.NET 3.5中为您定义的，但您可以为2.0目的重新声明它;-p

请注意，匿名方法（delegate {...}）也可以参数化：

    static void Main()
    {
        DoStuff(delegate (string s) {Foo(5);});
        DoStuff(delegate (string s) {Bar(s,"def");});
    }
    static void DoStuff(Action<string> action)
    {
        action("abc");
    }
    static void Foo(int i)
    {
        Console.WriteLine(i);
    }
    static void Bar(string s, string t)
    {
        Console.WriteLine(s+t);
    }

最后，C＃3.0使“lambdas”变得更加容易和漂亮，但这是另一个主题;-p

Answer 2

是的，可以将泛型与代表结合使用。

public delegate void Action<T>(T x);
public delegate void Action<T,U>(T x, U y);

public void UsingMutex<T>(Action<T> x, T t) {
    // acquire mutex...
    x(t);
    // release mutex...
}
public void UsingMutex<T,U>(Action<T,U> x, T t, U u) {
    // acquire mutex...
    x(t, u);
    // release mutex...
}

但是你仍然需要使用重载来处理不同数量的参数。

Answer 3

如果您查看框架中的Func<T>和Action<T>个委托，您会看到他们定义了许多具有不同参数数量的类似委托。您可以使用泛型，但这并不能解决您所讨论的参数问题。

C＃委托给两个具有不同参数的方法

3 个答案: