Come convertire EventArgs durante il cablaggio degli eventi?

Question

nelle applicazioni .NET, di solito gli eventi sono cablati in questo modo:

public event EventHandler<ChangeEventArgs> OnChange 
    { 
     add { _dependency.OnChange += value; } 
     remove { _dependency.OnChange -= value; } 
    } 

Tuttavia questo funziona solo se gli eventi che si cablati hanno lo stesso gestore di eventi. Nel mio caso attuale, l'evento originale args è proprietario di una libreria e non voglio esporlo al codice client. Quindi ho una sorta di adattatore (ChangeEventArgs). Come posso usare il codice sopra per convertire gli argomenti degli eventi? Immagino qualcosa di simile al di sotto (ma al di sotto codice non funziona)

public event EventHandler<ChangeEventArgs> OnChange 
    { 
     add { _dependency.OnChange += Convert(value); } 
     remove { _dependency.OnChange -= Convert(value); } 
    } 

o

public event EventHandler<ChangeEventArgs> OnChange 
    { 
     add { _dependency.OnChange += value(this, Convert(args)); } 
     remove { _dependency.OnChange -= value(this, Convert(args)); } 
    } 

Answer 1

Prova questa:

public class SomeClassAdapter 
{ 
    private readonly SomeClass obj; 

    public SomeClassAdapter(SomeClass obj) 
    { 
     this.obj = obj; 
     this.obj.SomeEvent += HandleSomeClassSomeEvent; 
    } 

    private void HandleSomeClassSomeEvent(object sender, SomeEventArgs args) 
    { 
     OnSomeEvent(ConvertEventArgs(args)); 
    } 

    private MyEventArgs ConvertEventArgs(SomeEventArgs args) 
    { 
     // the magic goes here... 
    } 

    protected virtual void OnSomeEvent(MyEventArgs args) 
    { 
     var handler = SomeEvent; 
     if (handler != null) 
     { 
      handler(this, args); 
     } 
    } 

    public event EventHandler<MyEventArgs> SomeEvent; 
} 

Update.
Questo codice utilizza una versione più complessa del modello di adattatore, rispetto al codice. SomeClassAdapter è un adattatore per SomeClass (ha l'istanza SomeClass nel suo campo privato obj).

Il codice cliente si abbona a mySomeClassAdapter.SomeEvent. Il mio codice, a sua volta, si abbona a SomeClass.SomeEvent. Quando viene attivato SomeClass.SomeEvent, viene chiamato il gestore di eventi (HandleSomeClassSomeEvent). Questo gestore eventi converte SomeEventArgs in MyEventArgs e genera SomeClassAdapter.SomeEvent.

Quindi, abbiamo la catena: SomeClass.SomeEvent ->HandleSomeClassSomeEvent ->SomeClassAdapter.SomeEvent. Sembra "proxy di eventi".

Answer 2

Ci sono una cosa poco che devi fare qui, mi piacerebbe ho intenzione di assumere il tipo di ritorno del metodo Convert() sta per essere chiamato SupportedChangeEventArgs

Il modello normale sarebbe quindi quella di avere:

public event EventHandler<SupportedChangeEventArgs> Changed; // per http://msdn.microsoft.com/en-us/library/h0eyck3s%28v=vs.71%29.aspx 

Add hanno un membro virtuale che genera l'evento

public virtual void OnChanged(ChangeEventArgs e) 
{ 
    if(Changed != null) 
    { 
     Changed(this, Convert(e)); 
    } 
}