PostSharp - il tisse - pensées

Question

J'envisage d'utiliser le cadre Postsharp pour alléger le fardeau de la journalisation des méthodes d'application. Cela me permet essentiellement de décorer des méthodes avec l'attribut de journalisation et, au moment de la compilation, injecte le code de journalisation nécessaire dans le il. J'aime cette solution car elle évite le bruit dans l'environnement de code temporel de deign. Des idées, des expériences ou de meilleures alternatives?

Answer 1

J'applique la journalisation avec AOP avec Castle Windsor DynamicProxies. J'utilisais déjà Castle pour son conteneur IoC, donc l'utiliser pour AOP était le chemin de moindre résistance pour moi. Si vous souhaitez plus d'informations, faites-le-moi savoir, je suis en train de nettoyer le code pour le publier sous forme de blog

Modifier

Ok, voici le code de base Intercepter, faily basic mais il fait tout ce dont j'ai besoin. Il y a deux intercepteurs, l'un journal Everyhing et l'autre vous permet de définir des noms de méthodes pour permettre une journalisation plus fine. Cette solution dépend de Castle Windsor.

Classe de base abstraite

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;
        }
    }
}
}

Implémentation de la journalisation complète

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

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

Journalisation de la méthode

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

+1 sur postsharp. Je l'utilise depuis plusieurs choses (y compris quelques tentatives pour ajouter des conditions préalables et post-conditions au code C #) et je ne sais pas comment je le ferais sans cela ...

Answer 3

Cela dépend dans une certaine mesure de la durée pendant laquelle vous développerez et soutiendrez le projet. Certes, le tissage IL est une technologie intéressante, mais que se passe-t-il si le format des métadonnées IL et / ou de l'assemblage change à nouveau (comme il l'a fait entre 1.1 et 2.0) et que ces modifications rendent l'outil incompatible avec le nouveau format?

Si vous dépendez de l'outil, il vous empêchera de mettre à niveau votre technologie jusqu'à ce que l'outil le prenne en charge. En l'absence de garanties en place sur ce sujet (ou même sur le fait que le développement va se poursuivre, bien que cela semble probable), je serais très prudent quant à son utilisation dans un projet à long terme.

À court terme, pas de problème cependant.

Answer 4

Je l'ai utilisé pour faire exactement cela. Fonctionne très bien! Je le recommande vivement!