PostSharp: как украсить возвращение IEnumerable <T>? - PullRequest
Новая
       11

PostSharp: как украсить возвращение IEnumerable <T>?

0 голосов
/ 06 февраля 2019

Как заставить это работать? 

public override void OnExit(MethodExecutionArgs args) {
    var enumerable = (IEnumerable) args.ReturnValue;
    return Log( 
            enumerable, // How to cast to unknown generic type?
            () => logger.LogRequestEntry(),
            stopwatch => logger.LogRequestExit( stopwatch ),
            ex => logger.LogRequestError( ex ) );
}


private static IEnumerable<T> Log<T>(IEnumerable<T> enumerable, Func<Stopwatch> logEntry, Action<Stopwatch> logExit, Action<Exception> logError) {
    var stopwatch = logEntry();
    try {
        using (var enumerator = enumerable.GetEnumerator()) {
            while (MoveNext( enumerator, logError )) yield return enumerator.Current;
        }
    } finally {
        logExit( stopwatch );
    }
}

private static bool MoveNext<T>(IEnumerator<T> enumerator, Action<Exception> logError) {
    try {
        return enumerator.MoveNext();
    } catch (Exception ex) {
        logError( ex );
        throw;
    }
}

Ответы [ 2 ]

0 голосов
/ 05 апреля 2019

Вам нужно использовать отражение, чтобы построить возвращаемое значение правильного универсального типа.Однако вы можете переместить весь код отражения в логику времени сборки и повысить производительность во время выполнения.Вы можете создать общий экземпляр аспекта во время сборки, как показано ниже. 

[PSerializable]
public class LogEnumerableRequestAttribute : MethodLevelAspect, IAspectProvider
{
    public IEnumerable<AspectInstance> ProvideAspects( object targetElement )
    {
        var @interface = ( (MethodInfo) targetElement ).ReturnParameter.ParameterType;
        if (!IsGenericIEnumerable(@interface))
        {
            @interface = @interface.GetInterfaces().First( IsGenericIEnumerable );
        }

        var generic = @interface.GetGenericArguments().First();
        var aspectGenericType = typeof( LogEnumerableRequestImpl<> ).MakeGenericType( generic );

        yield return new AspectInstance(
            targetElement, (IAspect) Activator.CreateInstance( aspectGenericType ) );
    }

    private static bool IsGenericIEnumerable( Type t )
    {
        return t.IsGenericType && t.GetGenericTypeDefinition() == typeof( IEnumerable<> );
    }
}

[PSerializable]
public class LogEnumerableRequestImpl<T> : IMethodLevelAspect
{
    [OnMethodExitAdvice(SemanticallyAdvisedMethodKinds = SemanticallyAdvisedMethodKinds.None)]
    [SelfPointcut]
    public void OnMethodExit( MethodExecutionArgs args )
    {
        args.ReturnValue = Log_( (IEnumerable<T>) args.ReturnValue );
    }

    public void RuntimeInitialize( MethodBase method )
    {
    }

    private static IEnumerable<T> Log_<T>( IEnumerable<T> enumerable, Func<Stopwatch> logEntry, Action<Stopwatch> logExit, Action<Exception> logError )
    {
        // ...
    }

    private static bool MoveNext<T>( IEnumerator<T> enumerator, Action<Exception> logError )
    {
        // ...
    }
}
0 голосов
/ 07 февраля 2019

выглядит некрасиво, но работает.Если бы C # поддерживал динамический для статических членов, это могло бы быть лучше, но теперь мы можем использовать отражение только для вызова статического метода. 

    private static readonly MethodInfo LogMethod = typeof( LogEnumerableRequestAttribute ).GetMethod( nameof( Log_ ), BindingFlags.NonPublic | BindingFlags.Static );


    public static IEnumerable Log(IEnumerable enumerable, Func<Stopwatch> logEntry, Action<Stopwatch> logExit, Action<Exception> logError) {
        var @interface = enumerable.GetType().GetInterfaces().First( i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof( IEnumerable<> ) );
        var generic = @interface.GetGenericArguments().First();
        var method = LogMethod.MakeGenericMethod( generic );
        return (IEnumerable) method.Invoke( null, new object[] { enumerable, logEntry, logExit, logError } );
    }

    private static IEnumerable<T> Log_<T>(IEnumerable<T> enumerable, Func<Stopwatch> logEntry, Action<Stopwatch> logExit, Action<Exception> logError) {
        var stopwatch = logEntry();
        try {
            using (var enumerator = enumerable.GetEnumerator()) {
                while (MoveNext( enumerator, logError )) yield return enumerator.Current;
            }
        } finally {
            logExit( stopwatch );
        }
    }

    private static bool MoveNext<T>(IEnumerator<T> enumerator, Action<Exception> logError) {
        try {
            return enumerator.MoveNext();
        } catch (Exception ex) {
            logError( ex );
            throw;
        }
    }
...