Come utilizzare le interfacce nella gestione delle eccezioni

Question

Sto lavorando al livello di gestione delle eccezioni per la mia applicazione.

Ho letto alcuni articoli su interfacce e farmaci generici. Ho usato l'eredità prima di parecchio e mi sento a mio agio in quell'area.

Ho un brevissimo design che ho intenzione di implementare:

public interface IMyExceptionLogger 
{ 
    public void LogException(); 

    // Helper methods for writing into files,db, xml 
} 

Sono un po 'confuso che cosa dovrei fare dopo.

public class FooClass: IMyExceptionLogger 
{ 

    // Fields 
    // Constructors 

} 

Devo implementare LogException() metodo all'interno FooClass? Se sì, allora sto cercando di capire come utilizzare l'interfaccia al posto della classe di cemento ...

Ho una varietà di classi che faranno uso di quell'interfaccia, ma non lo faccio t voglio scrivere un'implementazione di quell'interfaccia all'interno di ogni classe.

Nello stesso tempo, se a implementare un'interfaccia in una classe, e quindi utilizzare tale classe in diversi strati dell'applicazione sarò ancora utilizzando classi concrete invece di interfacce, che è una cattiva progettazione OO ...

Spero che abbia senso.

Qualsiasi commento e suggerimento sono benvenuti.

Si prega di notare che io non sono interessato ad usare net4log o dei suoi concorrenti perché sto facendo questo per imparare.

Grazie

Edit:

ha scritto un po 'di codice. Così ho implementare varietà di logger con questa interfaccia, cioè DBExceptionLogger, CSVExceptionLogger, XMLExceptionLogger ecc Che sarò ancora finire con classi concrete che dovranno utilizzare in diversi strati di mia applicazione.

Answer 1

Non è possibile evitare di avere classi concrete che implementano IMyExceptionLogger. Tuttavia, è possibile interrompere le classi che devono eseguire la registrazione delle eccezioni dall'avere dipendenze su tali classi concrete. Ecco a cosa serve l'interfaccia. Quindi si inietta il logger come una dipendenza di tutte le classi che hanno bisogno di usarlo:

class MyClass 
{ 
    public MyClass(IMyExceptionLogger exceptionLogger) 
    { 
     .... 
     exceptionLogger.LogException(e); 
    } 
} 

Si potrebbe anche prendere in considerazione alcuni contenitori IoC quali Unity per aiutare a gestire queste dipendenze più facilmente.

Answer 2

definire un Logger interfaccia e di definire il maggior numero di implementazioni concrete come si desidera (attuazione).

Composizione di utilizzo successiva: ogni classe che deve registrare qualcosa deve avere un Logger immesso in esso (tramite l'argomento Ctor o un setter).

Questo suona più naturale per me.

Answer 3

Sì, bisogna implementare il metodo LogException() nella FooClass.

Vantaggio delle interfacce nel caso in cui è possibile creare il tipo concreto del registratore (FooClass o DBExceptionLogger o così) e passare solo il riferimento IMyExceptionLogger. In modo che tutte le classi che registrano le informazioni saranno indipendenti dalla realizzazione concreta del logger.

Answer 4

È necessario utilizzare un'interfaccia dire IExceptionLog. Se i clases concreti hanno molto in comune, ad es. XmlLogger, SOAPLogger puoi creare una classe base per quelli. Nelle classi in cui si desidera utilizzare il registratore, è necessario creare un membro con tipo IExceptionLog (l'interfaccia). Il valore di questo membro viene impostato utilizzando l'iniezione delle dipendenze. È possibile utilizzare se si desidera uno