C# Singleton Logging Class

Question

Sto cercando di capire la migliore strategia per l'accesso al server web async-IO su cui sto lavorando. Ho pensato che il modo più semplice era quello di avere una classe Singleton che mantiene filestreams aperto per i file di log appropriati in modo ho potuto solo fare qualcosa di simile:

Util.Logger.GetInstance().LogAccess(str); 

O qualcosa del genere.

La mia classe si presenta così:

public sealed class Logger { 
    private static StreamWriter sw; 
    private static readonly Logger instance = new Logger(); 
    private Logger() { 
     sw = new StreamWriter(logfile); 
    } 
    public static Logger GetInstance() { 
     return instance; 
    } 
    public void LogAccess(string str) { 
     sw.WriteLine(str); 
    } 
} 

Questo è tutto solo nella mia testa davvero, e non vedo per suggerimenti su come farlo meglio e fare in modo che sto facendo in modo corretto anche. La cosa più importante è che ho bisogno che sia thread-safe, che ovviamente non è nel suo stato attuale. Non sono sicuro del modo migliore per farlo.

Answer 1

C'è un metodo TextWriter.Synchronized che produce una versione thread-safe di TextWriter. Prova questo.

Answer 2

Non penso che ci sia un modo semplice per bloccare se si desidera scrivere sullo stesso file da più thread.

Quindi la soluzione semplice è aggiungere lock intorno a qualsiasi chiamata allo StreamWriter. In alternativa è possibile memorizzare in buffer l'output in memoria e scriverlo solo una volta ogni tanto, il che richiede comunque il blocco, ma la contesa del blocco sarebbe molto più bassa. Se si va a quella lunghezza, però, si potrebbe anche andare con un quadro di registrazione adeguato come log4net, which is thread-safe.

Answer 3

a) Non includere "Registro" nei nomi dei metodi. È ovvio che un logger registra. .Warning, .Error, ecc. Sono nomi di metodi migliori poiché descrivono il livello della voce di registro.

b) Creare un thread in background che scrive nel log.

c) Accedere alle voci dai metodi di registrazione e segnalare il thread di lavoro.

d) Utilizzo (non so se ricordo bene i nomi dei metodi)

var methodInfo = new StackFrame(1).GetMethod(); 
var classAndMethod = methodInfo.DeclaringType.Name + "." + methodInfo.Name; 

per ottenere il metodo chiamante.

In questo modo si otterrà solo un thread che accede al file.

Answer 4

Questo è gestito automaticamente se si utilizza NLog - si definiscono tutti i logger in un file .config e quindi si accede a tutti tramite la classe statica LogManager, che è un Singleton.

Ecco un esempio che illustra la natura thread-safe di NLog:

http://nlog-project.org/wiki/Tutorial#Adding_NLog_to_an_application

Answer 5

Forse dovresti provare NLog o Log4net. Entrambi sono meravigliosi framework di log.

Ma se si desidera scrivere il proprio componente di registro, Blocco è un must quando si generano messaggi di registro. È normale che i messaggi del registro vengano memorizzati in memoria e vengano scritti su file una volta alla volta.

Answer 6

Un altro framework che risolve questi problemi è the Object Guy's logging framework. Può facoltativamente accedere in background.Più thread possono accedere allo stesso file. E più processi possono accedere allo stesso file.

Answer 7

Oppure si potrebbe usare una classe con metodi condivisi solo ..

Imports System.Threading 

Public Class Logger 
    Private Shared ReadOnly syncroot As New Object 

    Public Shared Sub log(ByVal vInt As Integer) 
     ThreadPool.QueueUserWorkItem(New WaitCallback(AddressOf logThread), CStr(vInt)) 
    End Sub 

    Public Shared Sub log(ByVal vStr As String) 
     ThreadPool.QueueUserWorkItem(New WaitCallback(AddressOf logThread), vStr) 
    End Sub 

    Private Shared Sub logThread(ByVal o As Object) 
     Dim str As String = CStr(o) 
     SyncLock syncroot 
      Using objWriter As New System.IO.StreamWriter(GetLogPath, True) 

       objWriter.WriteLine(str) 
       objWriter.Close() 

      End Using 
     End SyncLock 
    End Sub 

    Private Shared Function GetLogPath() As String 
     Return "logs.txt" 
    End Function 
End Class 

ho trovato più utilizzabile in questo modo di utilizzare un Singleton:

Logger.log("Something to log") 

Acclamazioni