CODEWITHSUNDEEP
c#delegates
shakazed
shakazed

Reputation: 1503

Using one delegate to for several methods with different parameters

Is it possible to use one delegate for several methods with different parameters somehow? I use reflection to get all the methods in a class, and I want to assign each of them a delegate and save that delegate in a dictionary with an enum as the key. This if for a remote procedure call implementation I'm working on so the enum is a command associated with a method.

Regards/Per

Upvotes: 3

Views: 2026

Answers (4)

Islam Yahiatene
Islam Yahiatene

Reputation: 1469

You can use the Delegate.CreateDelegate Function and pass the appropriate delegate Type (Action<> or Func<>) and an instance of the MethodInfo, in this case you should construct the delegate type according to the MethodInfo parameters.

Upvotes: 1

Merlyn Morgan-Graham
Merlyn Morgan-Graham

Reputation: 59101

You could make a Dictionary<MyEnum, Object>;. After you extract the value, cast it to the appropriate delegate and invoke it.

Alternately, you could use something like the command pattern, and pass in commands rather than enumerated values:

interface ICommand
{
    void Execute();
}

class SomeCommand : ICommand
{
    public SomeCommand(/* instance and parameters go here */) { /* ... */ }

    public void Execute() { /* ... */ }
}

class SomeOtherCommand : ICommand { /* ... */ }

If you want them to be accessible like an enum, you could make a factory class w/ static methods to create your specific commands:

class RemoteCommand
{
    public static SomeCommand SomeCommand
    {
        get
        {
            var result = new SomeCommand(/* ... */);
            // ...
            return result;
        }
    }

    public static SomeOtherCommand SomeOtherCommand { get { /* ... */ } }
}

Edit:

Also, not sure of your needs, but exposing a list of method calls that the user might want to make, but abstracting out exactly what gets called sure sounds like an interface:

interface IRemoteCommand
{
    void RemoteMethod();
    void OtherRemoteMethod(/* params */);
    void ImplementedAgainstADifferentServerMethod();
}

Upvotes: 0

Daniel Earwicker
Daniel Earwicker

Reputation: 116654

You'd need a uniform way of passing them parameters. That means you'd need to pass them an array of parameters. And that means you need a MethodInfo, not a delegate.

Just store the MethodInfo against the name in the dictionary. Then when you need to call them, use the Invoke method to make the call, passing the target object and the array of parameters.

Upvotes: 1

Sky Sanders
Sky Sanders

Reputation: 37074

If the parameter count, order and type are the same, yes.

Simply put, a delegate is just a method signature.

Upvotes: 0

Related Questions