Aggiunta di eventi a un’interfaccia / implementazione

Sapere questo è stato chiesto prima, tuttavia la mia domanda è leggermente diversa.

Ho un’interfaccia:

IEmailDispatcher

Sembra questo:

public interface IEmailDispatcher { void SendEmail(string[] to, string fromName, string fromAddress, string subject, string body, bool bodyIsHTML, Dictionary Attachments); } 

Come un po ‘di background:

Ho una class EmailDispatcher statica che ha il metodo: SendEmail (stringa [] in, stringa fromName, stringa fromAddress, object stringa, corpo stringa, bool bodyIsHTML, dizionario allegati);

Questo, tramite IoC, carica la relativa implementazione di IEmailDispatcher e chiama tale metodo.

Le mie applicazioni possono quindi chiamare semplicemente EmailDispatcher.SendEmail (………

Voglio aggiungere eventi ad esso, ad esempio OnEmailSent, OnEmailFail, ecc. In modo che ogni implementazione possa gestire i successi e gli errori di invio di e-mail e registrarli di conseguenza.

Come potrei fare questo?

O c’è un modo migliore?

Al momento, sto usando un “BasicEmailDispatcher” che utilizza fondamentalmente gli spazi dei nomi System.Net, crea un MailMessage e lo invia.

In futuro, creerò un’altra class, che gestisce la posta in modo diverso … la aggiunge a una tabella sql db per la creazione di report ecc …. e quindi gestirà gli eventi OnEmailSent in modo diverso da BasicEmailDispatcher

Sembra che provare a inserire tutto nella class statica ti stia facendo fare cose strane (in particolare, implementando il modello di template usando una class statica). Se i chiamanti (applicazioni) devono solo conoscere il metodo SendEmail , questa è l’unica cosa che dovrebbe essere nell’interfaccia.

Se è così, puoi semplicemente fare in modo che la class dispatcher di base implementa il modello di modello:

 public class EmailDispatcherBase: IEmailDispatcher { // cheating on the arguments here to save space public void SendEmail(object[] args) { try { // basic implementation here this.OnEmailSent(); } catch { this.OnEmailFailed(); throw; } } protected virtual void OnEmailSent() {} protected virtual void OnEmailFailed() {} } 

Implementazioni più complesse erediterebbero entrambe da BasicEmailDispatcher (e quindi implementano IEmailDispatcher ) e sovrascrivono uno o entrambi i metodi virtuali per fornire un comportamento positivo o negativo:

 public class EmailDispatcherWithLogging: EmailDispatcherBase { protected override OnEmailFailed() { // Write a failure log entry to the database } } 
 public interface IEmailDispatcher { event EventHandler EmailSent; void SendEmail(string[] to, string fromName, string fromAddress, string subject, string body, bool bodyIsHTML, Dictionary Attachments); } 

Per maggiori dettagli, guarda qui.

È questa la risposta che stavi cercando?

Aggiungi gli eventi alla tua interfaccia:

 public interface IEmailDispatcher { void SendEmail(string[] to, string fromName, string fromAddress, string subject, string body, bool bodyIsHTML, Dictionary Attachments); event EmailSentEventHandler EmailSent; event EmailFailedEventHandler EmailFailed; } 

E nella tua class statica, usa accessors di eventi espliciti per iscriverti agli eventi dell’attuale implementazione:

 public static class EmailDispatcher { public event EmailSentEventHandler EmailSent { add { _implementation.EmailSent += value; } remove { _implementation.EmailSent -= value; } } public event EmailFailedEventHandler EmailFailed { add { _implementation.EmailFailed += value; } remove { _implementation.EmailFailed -= value; } } }