c# - programming - PostSharp-il weaving-pensamientos

aspect oriented programming c#

Question

Estoy considerando usar el marco de trabajo de Postsharp para aliviar la carga del registro del método de aplicación. Básicamente, me permite adornar métodos con el atributo de registro y en tiempo de compilación inyecta el código de registro necesario en el il. Me gusta esta solución ya que mantiene el ruido alejado del entorno del código de tiempo deignar. ¿Alguna idea, experiencia o mejores alternativas?

Answer 1

Aplico el registro con AOP usando Castle Windsor DynamicProxies. Ya estaba usando Castle para su contenedor IoC, así que usarlo para AOP fue el camino de menor resistencia para mí. Si quieres más información, házmelo saber, estoy en el proceso de poner en orden el código para publicarlo en una publicación de blog

Editar

Bien, aquí está el código básico de Intercepter, básicamente básico, pero hace todo lo que necesito. Hay dos interceptadores, uno registra todos y el otro le permite definir nombres de métodos para permitir un registro de grano más fino. Esta solución depende poco de Castle Windsor

Resumen Clase base

namespace Tools.CastleWindsor.Interceptors
{
using System;
using System.Text;
using Castle.Core.Interceptor;
using Castle.Core.Logging;

public abstract class AbstractLoggingInterceptor : IInterceptor
{
    protected readonly ILoggerFactory logFactory;

    protected AbstractLoggingInterceptor(ILoggerFactory logFactory)
    {
        this.logFactory = logFactory;
    }

    public virtual void Intercept(IInvocation invocation)
    {
        ILogger logger = logFactory.Create(invocation.TargetType);

        try
        {
            StringBuilder sb = null;

            if (logger.IsDebugEnabled)
            {
                sb = new StringBuilder(invocation.TargetType.FullName).AppendFormat(".{0}(", invocation.Method);

                for (int i = 0; i < invocation.Arguments.Length; i++)
                {
                    if (i > 0)
                        sb.Append(", ");

                    sb.Append(invocation.Arguments[i]);
                }

                sb.Append(")");

                logger.Debug(sb.ToString());
            }

            invocation.Proceed();

            if (logger.IsDebugEnabled && invocation.ReturnValue != null)
            {
                logger.Debug("Result of " + sb + " is: " + invocation.ReturnValue);
            }
        }
        catch (Exception e)
        {
            logger.Error(string.Empty, e);
            throw;
        }
    }
}
}

Implementación completa del registro

namespace Tools.CastleWindsor.Interceptors
{
using Castle.Core.Logging;

public class LoggingInterceptor : AbstractLoggingInterceptor
{
    public LoggingInterceptor(ILoggerFactory logFactory) : base(logFactory)
    {
    }
}
}

Registro de métodos

namespace Tools.CastleWindsor.Interceptors
{
using Castle.Core.Interceptor;
using Castle.Core.Logging;
using System.Linq;

public class MethodLoggingInterceptor : AbstractLoggingInterceptor
{
    private readonly string[] methodNames;

    public MethodLoggingInterceptor(string[] methodNames, ILoggerFactory logFactory) : base(logFactory)
    {
        this.methodNames = methodNames;
    }

    public override void Intercept(IInvocation invocation)
    {
        if ( methodNames.Contains(invocation.Method.Name) )
            base.Intercept(invocation);
    }
}
}

Answer 2

Lo he usado para hacer exactamente esto. ¡Funciona genial! ¡Lo recomiendo encarecidamente!

Answer 3

+1 en postsharp. He estado usando varias cosas (incluyendo algunos intentos de agregar condiciones previas y posteriores al código C #) y no sé cómo podría hacerlo sin eso ...

Answer 4

Depende en cierta medida de cuánto tiempo desarrollará y apoyará el proyecto. Claro, IL weaving es una buena tecnología, pero ¿qué ocurre si el formato de metadatos IL y / o conjunto cambia de nuevo (como lo hizo entre 1.1 y 2.0) y esos cambios hacen que la herramienta sea incompatible con el nuevo formato.

Si depende de la herramienta, entonces no podrá actualizar su tecnología hasta que la herramienta la admita. Sin garantías sobre esto (o incluso que el desarrollo continuará, aunque parece probable) entonces sería muy cauteloso sobre su uso en un proyecto a largo plazo.

A corto plazo, sin problema.