Decoratore di classe per dichiarare membro statico (ad es. Per log4net)?

Question

Sto utilizzando log4net, e abbiamo un sacco di questo nel nostro codice:

public class Foo { 
    private static readonly ILog log = LogManager.GetLogger(typeof(Foo)); 
    .... 
} 

Uno svantaggio è che significa che stiamo incollando questa sezione 10-word in tutto, e ogni ora e poi qualcuno dimentica di cambiare il nome della classe. Il log4net FAQ menziona anche questa possibilità alternativa, che è ancora più dettagliato:

public class Foo { 
    private static readonly ILog log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); 
    ... 
} 

È possibile scrivere un decoratore per definire questo? Mi piacerebbe davvero dire semplicemente:

[LogMe] // or perhaps: [LogMe("log")] 
public class Foo { 
    ... 
} 

Ho fatto cose simili in altre lingue, ma mai un linguaggio staticamente compilato come C#. Posso definire i membri della classe da un decoratore?

Modifica: Heh. Sono un programmatore Lisp. Apprezzo i suggerimenti per cambiare lingua, ma in realtà, se avessi intenzione di passare da una lingua all'altra per migliorare le capacità di metaprogrammazione, andrei fino a Lisp invece di esserne per metà. Sfortunatamente l'uso di una lingua diversa non è un'opzione su questo progetto.

Answer 1

Man questo sarebbe un gioco da ragazzi in python. Vorrei cercare in C# Attributes.

Answer 2

Attributes in .NET non sono decoratori/componenti attivi che influenzano la classe/membro a cui sono associati. Gli attributi sono meta-dati che possono essere recuperati con la riflessione. Non esiste una funzione simile a un decoratore in C#, anche se ci sono soluzioni AOP che estendono .NET con quello che vuoi. La soluzione più semplice è probabilmente quella di copiare semplicemente quella linea in ogni classe.

Answer 3

Questo è esattamente un compito per AOP - Aspect Oriented Programming. Date un'occhiata a PostSharp, è un framework AOP .NET, vi permetterà di fare esattamente quello che volete.

Questo funziona modificando (o tessendo) il codice IL in post-compilazione e aggiungendo l'aspetto di registrazione al metodo decorato.

MODIFICA: Sembra che PostSharp sia ora un prodotto commerciale. Se stai cercando una soluzione open source (gratuita), suggerisco LinFu AOP.

Answer 4

Se si tratta di ASP.NET o Windows Form, è possibile creare una pagina di base o un modulo di base da cui derivano tutti i moduli/pagine. Puoi dichiarare questo membro a quel livello e probabilmente ottenere ciò che desideri.

Answer 5

Probabilmente si potrebbe implementare una soluzione con l'aiuto di PostSharp o un altro strumento di programmazione orientata agli aspetti.

Sarebbe piuttosto banale usare una macro in Boo, ma questo non aiuterebbe molto la tua situazione.

Answer 6

Forse un modo semplice sarebbe quella di scrivere un metodo di estensione in un'interfaccia, quindi la classe solo bisogno di "attuare" (ma non tanto perché l'estensione fa l'impl) l'interfaccia

public class Foo : IGetLog<Foo> 
{ 

} 

L'estensione qualcosa di simile a....

public interface IGetLog<T> { } 

    public static class IGetLogExtension 
    { 
    public static ILog GetLogger<T>(this IGetLog<T> getLog) 
    { 
     return LogManager.GetLogger(typeof(T)); 
    } 
    } 

Answer 7

Abbiamo eseguito il wrapping di log4net in modo da poterlo sostituire con facilità. È qualcosa su cui potremmo davvero cambiare idea in futuro.

Mentre non stiamo facendo questo, e probabilmente farai un colpo di performance per farlo ... e sono davvero esitante a suggerirlo anche perché non sono sicuro che sia una buona idea ... ... potresti ... se ti sentissi abbastanza diabolico ... avvolgere log4net e fare qualcosa del genere nel tuo involucro.

var callingType = new System.Diagnostics.StackTrace().GetFrame(1).GetMethod().DeclaringType 

Se sei intelligente su come stai registrando si potrebbe sostenere solo quel costo quando è necessario il messaggio di registro.

Answer 8

usiamo qualcosa quasi identico:

private static readonly ILog Logger = LogManager.GetLogger(); 

Questo metodo è implementato come segue:

[MethodImpl(MethodImplOptions.NoInlining)] 
public static ILog GetLogger() 
{ 
    Type t; 
    try { t = new StackFrame(1, false).GetMethod().DeclaringType; } 
    catch { t = typeof(UnknownObject); } 
    return GetLogger(t); 
} 
private static class UnknownObject { } 

Si dimostra ancora di essere più di un dolore che io sono disposto a passare attraverso. Preferisco di gran lunga un oggetto statico con metodi statici per la registrazione. Ottenere il metodo di chiamata non è così costoso purché non si ottengano informazioni sui file. Rispetto alla sola chiamata di Log4Net per ottenere il tipo di chiamata è nulla (a seconda dei logger utilizzati).