Question

I am using the following methods:

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

and

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

From what I have found so far it seems that it is not possible to use a single delegate for two methods with different signatures.

Are there any other alternatives to write something like this:

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

All I can think for the moment is to use two delegates and a boolean flag to know which delegate to call, but it is not a long term solution.

It is possible to combine generics with delegates? And if so, do you have some links for any kind of documentation?

Environment: C# 2.0

Answer 1

Absolutely you can mix delegates with generics. In 2.0, Predicate<T> etc are good examples of this, but you must have the same number of args. In this scenario, perhaps an option is to use captures to include the args in the delegate?

i.e.

    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);     } 

Note that Action is defined for you in .NET 3.5, but you can re-declare it for 2.0 purposes ;-p

Note that the anonymous method (delegate {...}) can also be parameterised:

    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);     } 

Finally, C# 3.0 makes this all a lot easier and prettier with ‘lambdas’, but that is another topic ;-p