Dependency Injection wcf

Solution 1:

When you use svcutil.exe or the Add Service Reference wizard in Visual Studio, one of the many types auto-generated will be a client interface. Let's call it IMyService. There will also be another auto-generated interface called something like IMyServiceChannel that implements IMyService and IDisposable. Use this abstraction in the rest of your client application.

Since you want to be able to create a new channel and close it again, you can introduce an Abstract Factory:

public interface IMyServiceFactory
{
    IMyServiceChannel CreateChannel();
}

In the rest of your client application, you can take a dependency on IMyServiceFactory:

public class MyClient
{
    private readonly IMyServiceFactory factory;

    public MyClient(IMyServiceFactory factory)
    {
        if (factory == null)
        {
            throw new ArgumentNullException("factory");
        }

        this.factory = factory;
    }

    // Use the WCF proxy
    public string Foo(string bar)
    {
        using(var proxy = this.factory.CreateChannel())
        {
            return proxy.Foo(bar);
        }
    }
}

You can create a concrete implementation of IMyServiceFactory that wraps WCF's ChannelFactory<T> as an implementation:

public MyServiceFactory : IMyServiceFactory
{
    public IMServiceChannel CreateChannel()
    {
        return new ChannelFactory<IMyServiceChannel>().CreateChannel();
    }
}

You can now configure your DI Container by mapping IMyServiceFactory to MyServiceFactory. Here's how it's done in Castle Windsor:

container.Register(Component
    .For<IMyServiceFactory>()
    .ImplementedBy<MyServiceFactory>());

Bonus info: Here's how to wire up a WCF service with a DI Container.

Solution 2:

Here is what I understand from your question:

You have an interface that is not related to WCF. Let's call it IInterface

You have a WCF client that used a service. Let's call the service contract: IService

you want the ServiceClient class that by default implements the IService when you add a service reference also to implement IInterface.

IF this is the case, you can use the fact that the ServiceClient class is marked as partial.

Just make another partial declaration for ServiceClient and add the interface you need (You have to make sure that the namespaces are equal for the auto-generated code and your code). It should look somthing like:

namespace [ServiceClient Namespace]
{
    public partial class ServiceClient : IInterface
    {
    }
}

Hope it helped.