Passare un valore di ritorno attraverso un EventHandler

Question

Sto cercando di scrivere su un'API e ho bisogno di chiamare un eventhandler quando ottengo i dati da una tabella. Qualcosa di simile a questo:

public override bool Run(Company.API api) 
    { 
     SomeInfo _someInfo = new SomeInfo(); 

     if (_someInfo.Results == 1) 
      return true; 
     else 
      return false; 

     using (MyTable table = new MyTable(api)) 
     { 
      table.WhenData += new EventHandler<DataEventArgs<Record>>(table_WhenData); 
      table.WhenDead += new EventHandler<EventArgs>(table_WhenDead); 
      table.Start(); 
     } 

    public void table_WhenData(object sender, DataEventArgs<Record> e) 
    { 
     return true; 
    } 

Il problema che Im che ha è che io non so come passare un valore di ritorno indietro dal table_WhenData al metodo Run.

Ive ha provato in molti modi (come provare a passare _someInfo al metodo) ma non riesco a ottenere la sintassi corretta.

Qualsiasi suggerimento è molto apprezzato.

Answer 1

Lo schema comune qui non è quello di restituire alcun dato dal gestore eventi, ma di aggiungere proprietà all'oggetto argomento evento in modo che l'utente dell'evento possa impostare le proprietà a cui il chiamante può accedere. Questo è molto comune nel codice di gestione dell'interfaccia utente; vedi il concetto di evento Annulla ovunque.

Quanto segue è uno pseudo codice e non è pronto per la compilazione. Il suo intento è mostrare lo schema.

public MyEventArgs : EventArgs 
{ 
    public bool Cancel{get;set;} 
} 

public bool fireEvent() 
{ 
    MyEventArgs e=new MyEventArgs(); 

    //Don't forget a null check, assume this is an event 
    FireEventHandler(this,e); 

    return e.Cancel; 
} 

public HandleFireEvent(object sender, MyEventArgs e) 
{ 
e.Cancel=true; 
} 

Modifica

Mi piace come Jon Skeet formulata questo: rendere il mutuable EventArgs. Cioè, il consumatore dell'evento può modificare lo stato dell'oggetto EventArgs consentendo al raiser dell'evento di accedere a tali dati.

Answer 2

L'unico modo per farlo è rendere modificabile uno degli argomenti (preferibilmente gli "arg" piuttosto che il mittente). Se non è già mutabile, hai fondamentalmente dei problemi: non c'è modo di estrarre l'informazione.

(Va bene, c'è un modo - è possibile mantenere l'argomento evento stesso immutabile, ma fare un membro di essa un metodo che finisce per chiamare un delegato registrato dal codice di verifica l'anomalia, in primo luogo, ma questo è orribile.. ..)

Answer 3

una soluzione semplice è quella di utilizzare una chiusura:

public override bool Run() { 
    SomeInfo someInfo = ... 
    table.WhenData += (obj, args) => { 
     someInfo.Return = something 
    }; 
} 

Answer 4

so che questo è un vecchio post, ma solo nel caso in cui qualcuno viene attraverso di esso, è certamente possibile farlo. Si dichiara il proprio delegato che restituisce un valore, quindi basare l'evento su questo nuovo delegato. Ecco un esempio:

In caso dichiarante/editore:

// the delegate 
public delegate string ReturnStringEventHandler(object sender, EventArgs args); 
// the event 
public event ReturnStringEventHandler StringReturnEvent; 
// raise the event 
protected void OnStringReturnEvent(EventArgs e) 
    { 
     if (StringReturnEvent != null) // make sure at least one subscriber 
       // note the event is returning a string 
       string myString = StringReturnEvent(this, e); 
    } 

In sottoscrittore dell'evento:

// Subscribe to event, probably in class constructor/initializer method 
StringReturnEvent += HandleStringReturnEvent; 

// Handle event, return data 
private string HandleStringReturnEvent(object sender, EventArgs e) 
{ 
    return "a string to return"; 
} 

.NET fornisce un esempio di questo nel caso AssemblyResolve, che utilizza il ResolveEventHandler delegato per restituire i dati, in questo caso un riferimento all'assembly desiderato. MSDN Article on AssemblyResolve event

Personalmente ho usato sia l'evento AssemblyResolve e la tecnica delegato personalizzato per restituire i dati da un evento, ed entrambi lavorano come previsto in Visual Studio 2010.