Używanie akcji jako argument w języku C# (naśladowanie wskaźnika funkcji)

Question

Potrzebuję napisać funkcję delegata, która może "owinąć" niektóre podczas/spróbować/złapać kod wokół podstawowego połączenia UDP, aby zweryfikować link. Udało mi się pracować dla Func dla funkcji, która nie ma argumentów, ale nie mogę sprawić, żeby działała na działanie, która ma argument (ale nie ma powrotu). Nie wydaje mi się, aby przekazać argument w logiczny sposób bez narzekania kompilatora.

Czy to wszystko źle? Jestem nowy w C# i zasadniczo próbuję naśladować ideę wskaźnika funkcji. Czy nie powinienem przeciążać tej funkcji? Wiem, że nie można przeciążać delegatów (zakładam, że dlatego Func i Action istnieją).

to działa:

protected TResult udpCommand<TResult>(Func<TResult> command) 
     { 
      TResult retValue = default(TResult); 
      while (!linkDownFail) 
      { 
       try 
       { 
        retValue = command(); 
        break; 
       } 
       catch 
       { 
        LinkStateCallBack(ip, getLinkStatus()); 
        if (linkDownFail) throw new LinkDownException(); 
        Thread.Sleep(100); 
       } 
      } 
      return retValue; 
     } 

Ale tego nie robi:

protected void udpCommand<T>(Action<T> command(T value)) 
     { 
      while(!linkDownFail) 
      { 
       try 
       { 
        command(value); 
        break; 
       } 
       catch 
       { 
        LinkStateCallBack(ip, getLinkStatus()); 
        if (linkDownFail) throw new LinkDownException(); 
        Thread.Sleep(100); 
       } 
      } 
      return; 
     } 

Wywołanie konwencji (na taki, który działa):

udpCommand<uint>(someUdpCommand); 

Answer 1

Jeśli chcesz to być wystarczająco rodzajowy obsługiwać dowolną liczbę argumentów spróbuj przy użyciu non-genernic działania delegat:

protected void udpCommand(Action command) 
{ 
    while(!linkDownFail) 
    { 
     try 
     { 
      command(); 
      break; 
     } 
     catch 
     { 
      LinkStateCallBack(ip, getLinkStatus()); 
      if (linkDownFail) throw new LinkDownException(); 
      Thread.Sleep(100); 
     } 
    } 
    return; 
} 

w C# 3.0, można nazwać tak:

udpCommand(() => noParameterMethod()); 
udpCommand(() => singleParameterMethod(value)); 
udpCommand(() => manyParameterMethod(value, value2, value3, value4)); 

W języku C# 2.0 to trochę brzydsze:

udpCommand(delegate { noParameterMethod(); }); 
udpCommand(delegate { singleParameterMethod(value); }); 
udpCommand(delegate { manyParameterMethod(value, value2, value3, value4); }); 

To daje wykonanie odroczony bez blokowania cię do konkretnego podpisu metody.

EDIT

Właśnie zauważyć Jakbym ukradł komentarz Marc Gravell za ... przeprosiny Marca. Aby odpowiedzieć jak można zmniejszyć powielania, można mieć metoda Action wywołać metodę Func<T> coś takiego:

protected void udpCommand(Action command) 
{ 
    udpCommand(() => { command(); return 0; }); 
} 

wierzę (a może się mylę), który wraca 0 nie jest bardziej kosztowne niż (domyślnie) powracający nieważny, ale mogę być daleko stąd.Nawet jeśli ma to jakiś koszt, wystarczy umieścić na stosie niewielki, mały, bitowy snoodge. W większości przypadków dodatkowe koszty nigdy nie wywołają żadnego smutku.

Answer 2

Chyba wystarczy wyjąć (wartość T) po "komendzie".

Answer 3

Czy chodziło Ci o:

protected void udpCommand<T>(Action<T> command, T value) {...} 

Z numerem:

udpCommand(someUdpCommand, arg); 

Zauważ, że to może działać lepiej na C# 3.0, który ma silniejsze niż wnioskowanie typu rodzajowego C# 2.0.

Answer 4

starasz się to zrobić ...

protected void udpCommand<T>(Action<T> command, T value) 
{ 
    while(!linkDownFail) 
    { 
    try     
    { 
     command(value); 
     // etc. 
    } 
    } 
} 

Wtedy będzie pracować tak ...

public void ActionWithInt(int param) 
{ 
    // some command 
} 

Action<int> fp = ActionWithInt; 

udpCommand<int>(fp, 10); // or whatever.