Kann ich eine Liste <T> als eine Sammlung von Methodenzeigern verwenden? (C#)

Question

Ich möchte eine Liste der auszuführenden Methoden erstellen. Jede Methode hat dieselbe Signatur. Ich dachte an die Delegierten in einer generischen Sammlung setzen, aber ich halte diesen Fehler:

'method' is a 'variable' but is used like a 'method'

In der Theorie ist hier, was würde ich tun mag:

List<object> methodsToExecute; 

int Add(int x, int y) 
{ return x+y; } 

int Subtract(int x, int y) 
{ return x-y; } 

delegate int BinaryOp(int x, int y); 

methodsToExecute.add(new BinaryOp(add)); 
methodsToExecute.add(new BinaryOp(subtract)); 

foreach(object method in methodsToExecute) 
{ 
    method(1,2); 
} 

Irgendwelche Ideen, wie man erreichen Dies? Danke!

Answer 1

Sie müssen die object in der Liste auf eine BinaryOp oder besser werfen, einen spezifischeren Typ-Parameter für die Liste verwenden: (oder 3,5)

delegate int BinaryOp(int x, int y); 

List<BinaryOp> methodsToExecute = new List<BinaryOp>(); 

methodsToExecute.add(Add); 
methodsToExecute.add(Subtract); 

foreach(BinaryOp method in methodsToExecute) 
{ 
    method(1,2); 
} 

Answer 2

Haben sie alle gemeinsame Schnittstelle implementieren, sagen IExecuteable, und haben dann eine Liste < IExecutable>

Auch mit Delegierten:

class Example 
{ 
    public delegate int AddDelegate(int x, int y); 

    public List<AddDelegate> methods = new List<AddDelegate>(); 

    int Execute() 
    { 
     int sum = 0; 
     foreach(AddDelegate method in methods) 
     { 
      sum+=method.Invoke(1, 2); 
     } 
     return sum; 
    } 
} 

Answer 3

Haben Sie versucht es nicht, aber eine Liste < Aktion mit < t >> Typ sollte in der Lage sein, es zu tun.

Answer 4

.NET 3.0 Verwenden Sie generische haben Delegierte.

Try this:

List<Func<int, int, int>> methodsToExecute = new List<Func<int, int, int>>(); 

methodsToExecute.Add(Subtract); 

methodsToExecute.Add[0](1,2); // equivalent to Subtract(1,2) 

Answer 5

List<Func<int, int, int>> n = new List<Func<int, int, int>>(); 
      n.Add((x, y) => x + y); 
      n.Add((x, y) => x - y); 
      n.ForEach(f => f.Invoke(1, 2)); 

Answer 6

I Khoth Implementierung besser gefallen, aber ich denke, was Ihr Compiler-Fehler verursacht ist, dass Sie die Methode zu einem BinaryOp nicht werfen, bevor Sie versuchen, es zu berufen. In Ihrer foreach-Schleife ist es nur ein "Objekt". Ändere deine foreach, um wie Khot's auszusehen, und ich denke, es würde funktionieren.

Answer 7

Immer, wenn ich in Versuchung gekommen bin, etwas zu tun, habe ich festgestellt, dass es im Allgemeinen besser ist, den Entwurf so zu modifizieren, dass er das Befehlsmuster verwendet, besonders da alle Methoden dieselben Parameter haben. Auf diese Weise wird viel mehr Flexibilität ermöglicht.