PostSharp - il tecelagem - pensamentos
-
01-07-2019 - |
Pergunta
Eu estou pensando em usar quadro PostSharp para aliviar a carga de registro de método de aplicação. Ele basicamente me permite métodos decora com atributo de registro e na injeta tempo compilar o código de registro necessário para o il. Eu gosto desta solução, uma vez que mantém o ruído do ambiente código de tempo deign. Quaisquer pensamentos, experiências ou melhores alternativas?
Solução
I aplicar logging com AOP usando o Castelo de Windsor DynamicProxies. Eu já estava usando Castelo para ele do contêiner IoC, então usá-lo para AOP foi o caminho de menor resistência para mim. Se você quiser mais informações me avise, eu estou no processo de arrumar o código acima para liberá-lo como um post
Editar
Ok, aqui está o código básico Intercepter, faily básico, mas faz tudo o que eu preciso. Há dois intercepters, um registos Everyhing eo outro permite definir nomes de métodos para permitir mais exploração madeireira grão fino. Esta solução é faily dependente de Castelo de Windsor
classe base abstrata ??strong>
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;
}
}
}
}
Logging completa Implemnetation
namespace Tools.CastleWindsor.Interceptors
{
using Castle.Core.Logging;
public class LoggingInterceptor : AbstractLoggingInterceptor
{
public LoggingInterceptor(ILoggerFactory logFactory) : base(logFactory)
{
}
}
}
logging Método
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);
}
}
}
Outras dicas
+1 em PostSharp. Têm vindo a utilizar para várias coisas (incluindo algumas tentativas sobre a adição de pré-condições e pós-condições para código C #) e não sei como eu tinha que fazer isso sem ele ...
Isso depende a uma extensão de quanto tempo você estará desenvolvendo e apoiando o projeto para. Claro, IL tecelagem é uma tecnologia boa, mas o que acontece se o formato IL e / ou montagem de metadados muda novamente (como fez entre 1,1 e 2,0) e essas mudanças tornam o incompatível ferramenta com o novo formato.
Se você dependem da ferramenta, em seguida, que o impede de atualizar sua tecnologia até que a ferramenta suporta. Sem garantias no lugar sobre este (ou mesmo que o desenvolvimento vai continuar, embora ele não parece provável), então eu seria muito cauteloso sobre a usá-lo em um projeto de longo prazo.
Curto prazo, não há problema embora.
tê-lo usado para fazer exatamente isso. Funciona bem! Eu recomendo!