Autofac Wcf-根据SOAP请求中的数据注入服务

Question

I have a WCF Service with the following operation contract:

[OperationContract]
Response SearchEntities(Query query);

This operation takes a request that contains a specified Entity like so:

[DataContract]
public class Query
{
    [DataMember]
    public string SearchTerm { get; set; }

    [DataMember]
    public string Entity { get; set; }

    [DataMember]
    public bool ExactMatch { get; set; }
}

Based on the value contained within the Entity property, one the following properties is populated within this response:

[DataContract]
public class Response
{
    [DataMember]
    public List<Asset> Assets { get; set; }

    [DataMember]
    public List<Stage> Stages { get; set; }

    [DataMember]
    public List<Sector> Sectors { get; set; }
}

Terrible design, I know! However. I am using Autofac.Wcf as my service factory to inject dependencies. Normally I would use a common Interface and Generics to determine a service to use based on the Entity value like so:

public interface IEntitySearch<T>
{
    Response Search(Query query);
}

The above interface would have several implementations for each of the Lists within the response. Using a design pattern such as a service location I could determine which service to use (all of which inherit from IEntitySearch<T> , something like:

public IEntitySearch ResolveSearcher(Query query)
{
    switch(query.Entity)
    {
        case "Assets":
            return _container.Resolve<AssetSearch>();
        case "Stages":
            return _container.Resolve<StageSearch>();
        default:
            throw new NotSupportedException();
    }
}

While this works, a more elegant solution (I believe) would be to customize the Autofac container per request for this particular operation, depending on the data contained within the request.

IE: Before the WCF pipe line sends the request to the service implementation, is it possible to examine the request data and customize how the container resolves dependencies. That way I can avoid exposing dependency resolution within my service layer.

Is this possible?

If another DI library other than Autofac has a solution for this, I will happily change our DI framework.

Thanks.

Answer 1

I haven't personally tried this but I think a direction you can go down is to combine:

• Using OperationContext.Current to get the current request message data.
• Specifying a custom IServiceImplementationDataProvider for Autofac that tells Autofac which WCF interface to host for that request.
• Using a lambda registration for your service implementation to switch the backing service based on OperationContext.Current .

You can see two examples of the IServiceImplementationDataProvider by looking at the DefaultServiceImplementationProvider - the one that works in Autofac WCF hosting by default; and MultitenantServiceImplementationDataProvider , which is more about generating a proxy to enable multitenant WCF hosting.

While neither of these use OperationContext.Current to determine the actual backing service, you can build on the ideas:

• Look at the Autofac.Multitenant.Wcf implementation. You may be able to use it as-is. The point of the instance data provider there is that WCF grabs on to the concrete type of the service being hosted and if you try to swap types out from under it, you get errors. The multitenant support fools WCF by creating a proxy type and your implementation type can be swapped out under the proxy. Note the MultitenantServiceImplementationDataProvider doesn't actually tie anything to a tenant or tenant ID; it's only about that proxy.
• In your .svc file specify a service interface rather than any individual concrete implementation since you'll be swapping out the implementation.
• Use a lambda registration to figure out your implementation.
• Make sure your service is InstanceContextMode.PerCall to ensure things get swapped out on a per request basis.

The registration might look something like this:

builder.Register(ctx => {
  var context = OperationContext.Current;
  var type = DetermineTypeFromContext(context);
  return ctx.Resolve(type);
}).As<IMyServiceInterface>();

The Autofac WCF and Autofac Multitenant section on WCF may also help.

Answer 2

In my opinion you're trying to move your problem just to another place. Why would making decision based on request at low-level WCF is better than switch in SearchEntities method? It's much worse ;-)

I would consider to use IEntitySearch factory/provider eq IEntitySearchProvider (it's not so much better but always).

public interface IEntitySearch
{
    bool IsMatchQuery(Query query);
    Response Search(Query query);
}

// without service locator
public class EntitySearchProvider : IEntitySearchProvider
{
    private readonly IEnumerable<IEntitySearch> _searchers;

    public EntitySearchProvider(IEnumerable<IEntitySearch> searchers)
    {
        _searchers = searchers;
    }

    public IEntitySearch GetSearcher(Query query)
    {
        // last registered 
        return _searchers.LastOrDefault(i=>i.IsMatchQuery(query))
            ??  throw new NotSupportedException();
    }
}

or

public interface IEntitySearchProvider
{
    IEntitySearch GetSearcher(Query query);
}

public class EntitySearchProvider : IEntitySearchProvider
{
    private readonly IComponentContext _container;

    public EntitySearchProvider(IComponentContext container)
    {
        _container = container;
    }

    public IEntitySearch GetSearcher(Query query)
    {
        switch(query.Entity)
        {
            case "Assets":
                return _container.Resolve<AssetSearch>();
            case "Stages":
                return _container.Resolve<StageSearch>();
            default:
                throw new NotSupportedException();
        }
    }
}

with

public class WcfService
{
    private readonly IEntitySearchProvider _provider;

    public WcfService(IEntitySearchProvider provider)
    {
        _provider = provider;
    }

    public Response SearchEntities(Query query)
    {
        var searcher = _provider.GetSearcher(query);
        return searcher.Search(query);
    }
}