Download the code for this post.

Update: This post is based on a older version of Ninject WCF Extensions. For an example of using the new version with REST support, see this post.

In my post on the Onion Architecture I highlight the use of Dependency Injection to loosen the coupling between application components.  In an ASP.NET MVC application, it is possible to use repositories directly from controllers, but it may be desirable to place a WCF services façade over the data access layer, so that other kinds of clients, such as Silverlight or WPF, won’t directly access the database.  This is commonly referred to as an n-tier application architecture.

For a service type to rely on a DI container for a repository interface, it would likely have a constructor that accepts an I_X_Repository parameter.

public class GreetingService : IGreetingService {
    private IGreetingRepository _greetingRepo;

    public GreetingService(IGreetingRepository greetingRepo)
    {
        _greetingRepo = greetingRepo;
    }

    public string Hello()
    {
        return _greetingRepo.GetGreeting();
    }
}

However, using this service type will result in an error: “The service type provided could not be loaded as a service because it does not have a default (parameter-less) constructor.”

To remedy this, you can use a custom instance provider to obtain the GreetingService from a DI container.  Thankfully, there is a NuGet package available that provides this service: Ninject.Extensions.Wcf.

To use this for a non-web host, set the KernelContainer’s Kernel property to an kernel initialized with a Ninject module that binds your types and interfaces.  Then use NinjectServiceHost in lieu of ServiceHost.

class Program {
    static void Main(string[] args)
    {
        // Init Ninject IKernel kernel = new StandardKernel(new HelloModule());
        KernelContainer.Kernel = kernel;

        // Create service host using (var host = new NinjectServiceHost(typeof(GreetingService),
            new Uri("http://localhost:1234/GreetingService")))
        {
            host.Open();
            Console.ReadKey();
        }
    }
}

The HelloModule binds both IGreetingRepository and ServiceHost.

public class HelloModule : NinjectModule {
    public override void Load()
    {
        Kernel.Bind<IGreetingRepository>().To<GreetingRepository>();
        Kernel.Bind<ServiceHost>().To<NinjectServiceHost>();
    }
}

In the .svc file for a web host, you would set the Factory property to NinjectServiceHostFactory.

<%@ ServiceHost Service="HelloNinjectWcf.Service.GreetingService" Factory="Ninject.Extensions.Wcf.NinjectServiceHostFactory" %>

Then add a Global.asax file that extends NinjectWcfApplication and overrides CreateKernel to return an initialized Ninject kernel.

public class Global : NinjectWcfApplication {
    protected override IKernel CreateKernel()
    {
        IKernel kernel = new StandardKernel(new HelloModule());
        return kernel;
    }
}

This works great for configuring a WCF service to use dependency injection, but there are times when you might need to spin up a WCF service for an integration test using a testing framework such as NUnit or MSTest.  This can get rather tedious, especially with DI in the mix.  For that reason, it’s convenient to use a helper class responsible for initializing both service host and client.  (Disclaimer: I have to credit my friend, Pete Young, for coming up with a helper that does this same sort of thing.)

public class NinjectServiceHelper<TServiceContract, TServiceType> : IDisposable {
    bool _disposed;

    public NinjectServiceHelper(string address, Binding binding, params Uri[] baseAddresses)
    {
        // Init Ninject service host _serviceHost = new NinjectServiceHost(typeof(TServiceType), baseAddresses);
        _serviceHost.AddServiceEndpoint(typeof(TServiceContract), binding, address);
        _serviceHost.Open();

        // Init client var factory = new ChannelFactory<TServiceContract>(binding);
        _client = factory.CreateChannel(new EndpointAddress(address));
    }

    private readonly ServiceHost _serviceHost;
    public ServiceHost ServiceHost 
    {
        get {
            if (_disposed)
                throw new ObjectDisposedException("NinjectServiceHelper");
            return _serviceHost; 
        }
    }

    private readonly TServiceContract _client;
    public TServiceContract Client
    {
        get {
            if (_disposed)
                throw new ObjectDisposedException("NinjectServiceHelper");
            return _client;
        }
    }

    public void Dispose()
    {
        if (!_disposed)
        {
            ((IDisposable)_serviceHost).Dispose();
            ((IDisposable)_client).Dispose();
            _disposed = true;
        }
    }
}

The code in the Test class then becomes nice and clean.

[TestFixture]
public class GreetingServiceTests {
    private NinjectServiceHelper<IGreetingService, GreetingService> _serviceHelper;

    [TestFixtureSetUp]
    public void FixtureSetup()
    {
        // Init Ninject IKernel kernel = new StandardKernel(new HelloModule());
        KernelContainer.Kernel = kernel;

        // Create service host _serviceHelper = new NinjectServiceHelper<IGreetingService, GreetingService>
            ("http://localhost:2345/GreetingService", new BasicHttpBinding());
    }

    [TestFixtureTearDown]
    public void FixtureTearDown()
    {
        ((IDisposable)_serviceHelper).Dispose();
    }

    [Test]
    public void Greeting_Method_Should_Return_Hello()
    {
        IGreetingService client = _serviceHelper.Client;
        using ((IDisposable)client)
        {
            string greeting = client.Hello();
            Assert.That(greeting, Is.StringMatching("Hello"));
        }
    }
}

Ninject.Extensions.Wcf makes it easy to leverage Ninject for dependency injection with WCF services.  My NinjectServiceHelper makes it easier to write integration tests that spin up the service and at the same time provides a client for invoking methods on the service and writing asserts on the results.  You can download the code for this blog post here.  Enjoy.