Autofac WCF集成 - 根据请求数据解析依赖关系

Question

How can I configure an Autofac container so it resolves the dependencies of a WCF service based on properties values of the operation-parameter (request object)?

For example, given this data contract...

[DataContract]
public class MyRequest
{
    [DataMember]
    public bool MyBool { get; set; }
}

this WCF service...

public class MyWcfService : IWcfService
{
    private IService m_service;

    public MyWcfService(IService service)
    {
        m_service = service;
    }

    public virtual MyResponse Operation(MyRequest request) { }
}

and these dependencies...

public interface IService { }
public class TypeA : IService { }
public class TypeB : IService { }

I would like the container to resolve TypeA if MyBool equals true and TypeB otherwise. Is that feature available? Should I approach the problem differently?

Constraints:

• Avoiding the Autofac.Extras.Multitenant package is a plus.
• Keeping the signature of the service constructor unchanged is also desired. (See my answer below)

Answer 1

There are a few ways to achieve this. One of the ways is to use IIndex<K,V> . It's built-in "lookup" feature that chooses between service implementations based on a key. You can find more info on Autofac's wiki page . An example code could look like:

// Register your dependency with a key, for example a bool flag
builder.RegisterType<TypeA>().Keyed<IService>(true);
builder.RegisterType<TypeB>().Keyed<IService>(false);

// Your service could look like:
public class MyWcfService
{
    private readonly IIndex<bool, IService> _services;

    // Inject IIndex<Key,Value> into the constructor, Autofac will handle it automatically
    public MyWcfService(IIndex<bool, IService> services)
    {
        _services = services;
    }

    public virtual void Operation(MyRequest request)
    {
        // Get the service that you need by the key
        var service = _services[request.MyBool];
    }
}

Another approach is to use Metadata feature. More information on wiki page .

Answer 2

Option 1 - Using Autofac:

The Autofac instance provider that creates your service instance does not use or pass along the operation's message. Here's the latest implementation of the method in Autofac. Notice the message parameter is unused.

public class AutofacInstanceProvider : IInstanceProvider
{
    // lots of code removed...

    public object GetInstance(InstanceContext instanceContext, Message message)
    {
        if (instanceContext == null)
        {
            throw new ArgumentNullException("instanceContext");
        }
        var extension = new AutofacInstanceContext(_rootLifetimeScope);
        instanceContext.Extensions.Add(extension);
        return extension.Resolve(_serviceData);
    }
}

So to get the behavior you want with existing Autofac code, you'll need to inject the dependency into your class using something other than constructor injection , which is @Alexandr Nikitin's solution . This is reasonable, but I agree with the comment "not loving it".

Option 2 - A Custom IInstanceProvider:

Writing a custom WCF IInstanceProvider is a reasonable option, but it will be a lot of code.

The good news is that the code in Autoface.Integration.WCF is a nice example and you could plug your implementation into Autofac.

The bad news is that Autofac.Integration.WCF code doesn't itself use dependency injection. For example AutofacDependencyInjectionServiceBehavior directly calls var instanceProvider = new AutofacInstanceProvider(_rootLifetimeScope, _serviceData) . As a result you'll you have to implement a replacement for AutofacInstanceProvider , AutofacDependencyInjectionServiceBehavior , AutofacHostFactory , and probably more. Then you'll need to create an extension for the AutofacInstanceContext to contain the information read from the message. Its a lot of code.

If you are going to do the custom IInstanceProvider I suggest reading up on Carlos Figueira's blog:

1. WCF Extensibility – IInstanceProvider - for good background
2. WCF Extensibility – Message Inspectors - Search for the section that starts with WCF Message objects can only be “consumed once". You'll need to follow these rules when inspecting the message.