PostSharp: How to decorate returning IEnumerable<T>? - postsharp

Question

How to get it work?
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;
}
}

Answer 1

You need to use reflection to construct the return value of the correct generic type. However, you can move all the reflection code to the build-time logic and improve the run-time performance. You can construct a generic instance of the aspect at build-time as shown below.
[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 )
{
// ...
}
}

Answer 2

It looks ugly but it works.
If C# supported dynamic for static members it could be better, but now we only can use reflection to call static method.
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;
}
}