通过 IAsyncInterceptor 使用 Autofac 接口拦截

Question

I did use this documentation: https://autofaccn.readthedocs.io/en/latest/advanced/interceptors.html

to implement Interface Interceptors. To handle my async calls I used the IAsyncInterceptor interface described here:

https://github.com/JSkimming/Castle.Core.AsyncInterceptor

The registration code I came up with does look like this:

 builder.Register(c => new CallResultLoggerInterceptor())
    .Named<IAsyncInterceptor>("log-calls");

  builder.RegisterType<AppointmentService>()
    .As<IAppointmentService>()
    .EnableInterfaceInterceptors()
    .InstancePerDependency();

where the AppointmentService has an InterceptAttribute.

 [Intercept("log-calls")]
 public class AppointmentService : IAppointmentService
 ...

When i call the containers Build() method, it throws an ComponentNotRegisteredException with the message:

The requested service 'log-calls (Castle.DynamicProxy.IInterceptor)' has not been registered. To avoid this exception, either register a component to provide the service, check for service registration using IsRegistered(), or use the ResolveOptional() method to resolve an optional dependency.

which is correct because I do not implement IInterceptor but IAsyncInterceptor. I guess the problem is the concrete implementation of EnableInterfaceInterceptors in autofac using the "wrong" extension method of the ProxyGenerator - but how can I solve this?

Cheers, Manuel

Answer 1

You need to register a named IInterceptor for Autofac interceptors to work. You're registering an IAsyncInterceptor . That won't work.

Note Autofac has no support for this extended async interceptor extension you're using. If you want to get that to work, it'll require writing a custom adapter of some nature to get it to respond to IInterceptor .

Answer 2

You can see my answer in the issue of Castle.Core.AsyncInterceptor: https://github.com/JSkimming/Castle.Core.AsyncInterceptor/issues/42#issuecomment-592074447

1. create an adapter

public class AsyncInterceptorAdaper<TAsyncInterceptor> : AsyncDeterminationInterceptor
  where TAsyncInterceptor : IAsyncInterceptor
{
    public AsyncInterceptorAdaper(TAsyncInterceptor asyncInterceptor)
        : base(asyncInterceptor)
    { }
}

2. create your async interceptor

public class CallLoggerAsyncInterceptor : AsyncInterceptorBase  
{
  ....
}

3. relate the interceptor to interface

[Intercept(typeof(AsyncInterceptorAdaper<CallLoggerAsyncInterceptor>))]
public interface ISomeType

4. register to IoC container

//register adapter
builder.RegisterGeneric(typeof(AsyncInterceptorAdaper<>));
//register async interceptor
builder.Register(c => new CallLoggerAsyncInterceptor(Console.Out));   

I've made a code sample in https://github.com/wswind/aop-learn/blob/master/AutofacAsyncInterceptor

Answer 3

I've created my own extension method for registering application services. This extension method simply prepares input parameter for castle core ProxyGenerator .

using System;
using System.Collections.Generic;
using System.Linq;
using Castle.DynamicProxy;
using Autofac;

namespace pixi.Extensions
{
    public static class AutofacExtensions
    {
        private static readonly ProxyGenerator _proxyGenerator = new ProxyGenerator();

        /// <summary>
        /// Use this extension method to register default interceptors <code>UnitOfWorkInterceptor</code>
        /// and <code>LoggingInterceptor</code> on your application service implementations. If you need custom
        /// interceptors that are not part of infrastructure but are part of specific business module then pass
        /// in those interceptors in params explicitly.
        /// </summary>
        /// <param name="builder"></param>
        /// <param name="interceptors"></param>
        /// <typeparam name="TImplementation"></typeparam>
        /// <typeparam name="TService"></typeparam>
        /// <exception cref="ArgumentException"></exception>
        public static void RegisterApplicationService<TImplementation, TService>(this ContainerBuilder builder, params Type[] interceptors)
            where TImplementation : class
        {
            ValidateInput<TService>(interceptors);

            builder.RegisterType<TImplementation>().AsSelf();

            builder.Register(c =>
            {
                var service = c.Resolve<TImplementation>();
                var resolvedInterceptors = ResolveInterceptors<TImplementation, TService>(interceptors, c);

                return (TService) _proxyGenerator.CreateInterfaceProxyWithTarget(
                        typeof(TService),
                        service,
                        ProxyGenerationOptions.Default,
                        resolvedInterceptors
                    );
            }).As<TService>();
        }

        private static void ValidateInput<TService>(Type[] interceptors)
        {
            if (!typeof(TService).IsInterface)
                throw new ArgumentException("Type must be interface");
            if (interceptors.Any(i => i != typeof(IAsyncInterceptor)))
                throw new ArgumentException("Only IAsyncInterceptor types are expected");
        }

        private static IAsyncInterceptor[] ResolveInterceptors<TImplementation, TService>(Type[] interceptors,
            IComponentContext c) where TImplementation : class
        {
            var resolvedInterceptors = new List<IAsyncInterceptor>
            {
                c.Resolve<LoggingInterceptor>(),
                c.Resolve<UnitOfWorkInterceptor>()
            }.Concat(interceptors
                .Where(i => i != typeof(UnitOfWorkInterceptor)
                            && i != typeof(LoggingInterceptor))
                .Select(i => (IAsyncInterceptor) c.Resolve(i))).ToArray();
            return resolvedInterceptors;
        }
    }
}

I am using castle core for unit of work and logging hence the name UnitOfWorkInterceptor and LogginInterceptor . Change these two to your desired defaults. Default interceptors must be registered in this way:

public class SomeModule: Module
    {
        protected override void Load(ContainerBuilder builder)
        {
            builder.RegisterType<UnitOfWorkInterceptor>().AsSelf();
            builder.RegisterType<LoggingInterceptor>().AsSelf();
            builder.RegisterApplicationService<SampleService, ISampleService>();
            builder.RegisterType<SampleRepository>().As<ISampleRepository>();
        }
    }

In the above code snippet I've also demonstrated the usage provided extension method. Doing it this way I get red of tag interfaces and placing extra attributes on interfaces. That way I can keep my ApplicationService interfaces free of framework/3rd party library dependencies.

I hope this helps.