trucos de rendimiento para C# Registro

Question

Estoy buscando en C# tala y yo no quiero que mis mensajes de registro que pasar ningún tiempo de procesamiento si el mensaje está por debajo del umbral de la tala. Lo mejor que veo que log4net hace es una comprobación de umbral DESPUÉS de evaluar los parámetros de registro.

Ejemplo:

_logger.Debug("My complicated log message " + thisFunctionTakesALongTime() + " will take a long time") 

Incluso si el umbral está por encima de Depuración, thisFunctionTakesALongTime todavía serán evaluados.

En log4net que se supone que usar _logger.isDebugEnabled por lo que terminan con

if(_logger.isDebugEnabled) 
    _logger.Debug("Much faster") 

quiero saber si hay una mejor solución para el registro de .NET que no implique un cheque cada vez que quiero iniciar sesión.

En C++ se me permite hacer

LOG_DEBUG("My complicated log message " + thisFunctionTakesALongTime() + " will take no time") 

desde mi macro LOG_DEBUG le examina el nivel de registro en sí. Esto me libera para tener un mensaje de registro de 1 línea a lo largo de mi aplicación que prefiero mucho. ¿Alguien sabe de una manera de replicar este comportamiento en C#?

Answer 1

Si puede orientar .NET 3.5 (C# 3.0) puede usar extension methods para envolver las declaraciones if.

para que pueda hacer el "macro" equivalente:

logger.Log_Debug("Much faster"); 

logger.Log_Debug(() => { "My complicated log message " + thisFunctionTakesALongTime() + " will take no time" }); 

envolviendo la verificación en este método:

public class Log4NetExtensionMethods { 
    // simple string wrapper 
    public void Log_Debug(this log4net.ILog logger, string logMessage) { 
     if(logger.isDebugEnabled) { 
      logger.Debug(logMessage); 
     } 
    } 

    // this takes a delegate so you can delay execution 
    // of a function call until you've determined it's necessary 
    public void Log_Debug(this log4net.ILog logger, Func<string> logMessageDelegate) { 
     if(logger.isDebugEnabled) { 
      logger.Debug(logMessageDelegate()); 
     } 
    } 
} 

Answer 2

Sin un preprocesador que estás SOL. Por supuesto, no hay nada que le impida usar uno antes de alimentar su código al compilador de C#.

Answer 3

El problema aquí es que todos los parámetros del método deben ser evaluados antes de invocar el método. No hay forma de evitar esto, dada la sintaxis que está usando. Como C# no tiene un preprocesador real o macros, no puede hacer nada como "LOG_DEBUG". Lo mejor que puede hacer es usar if (logger.isDebugEnable) según lo sugerido.

La única cosa que puedo pensar es tal vez el uso de algo como una expresión lambda para retrasar la evaluación. Pero te advertiría que esto es casi seguro que tienen más de un impacto en el rendimiento en el extremo.

internal class Sample 
{ 
    private static void Main(string[] args) 
    { 
     DelayedEvaluationLogger.Debug(logger,() => "This is " + Expensive() + " to log."); 
    } 

    private static string Expensive() 
    { 
     // ... 
    } 
} 

internal static class DelayedEvaluationLogger 
{ 
    public static void Debug(ILog logger, Func<string> logString) 
    { 
     if (logger.isDebugEnabled) 
     { 
      logger.Debug(logString()); 
     } 
    } 
} 

Answer 4

17.4.2 El atributo condicional

El atributo condicional permite la definición de métodos condicionales. El atributo Condicional indica una condición al probar un símbolo de compilación condicional. Las llamadas a un método condicional se incluyen u omiten dependiendo de si este símbolo está definido en el punto de la llamada. Si el símbolo está definido, la llamada está incluida; de lo contrario, la llamada (incluida la evaluación de los parámetros de la llamada) se omite.

[ Conditional("DEBUG") ] 
public static void LogLine(string msg,string detail) 
{ 
    Console.WriteLine("Log: {0} = {1}",msg,detail); 
} 

public static void Main(string[] args) 
{ 
    int Total = 0; 
    for(int Lp = 1; Lp < 10; Lp++) 
    { 
     LogLine("Total",Total.ToString()); 
     Total = Total + Lp; 
    } 
}