Dependency resolver for Web API using structure map.

StructureMapDependencyResolver.cs

using StructureMap;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Dependencies;

/// <summary>
/// Defines the dependency resolver using structure map.
/// </summary>
public sealed class StructureMapDependencyResolver : IDependencyResolver, IDisposable
{
    private readonly IContainer container;
    bool disposed = false;

    /// <summary>
    /// Initializes an instance of <see cref="StructureMapDependencyResolver"/> class.
    /// </summary>
    /// <param name="container">The container.</param>
    public StructureMapDependencyResolver(IContainer container)
    {
        this.container = container;
    }

    /// <summary>
    /// Starts a resolution scope.
    /// </summary>
    /// <returns>The dependency scope.</returns>
    public IDependencyScope BeginScope()
    {
        var nestedContainer = container.GetNestedContainer();
        return new StructureMapDependencyResolver(nestedContainer);
    }

    /// <summary>
    /// Resolves singly registered services that support arbitrary object creation.
    /// </summary>
    /// <param name="serviceType">The type of the requested service or object.</param>
    /// <returns>
    /// The requested service or object.
    /// </returns>
    public object GetService(Type serviceType)
    {
        if (serviceType.IsAbstract == false && serviceType.IsInterface == false)
        {
            return container.GetInstance(serviceType);
        }

        return container.TryGetInstance(serviceType);
    }

    /// <summary>
    /// Resolves multiply registered services.
    /// </summary>
    /// <param name="serviceType">The type of the requested services.</param>
    /// <returns>
    /// The requested services.
    /// </returns>
    public IEnumerable<object> GetServices(Type serviceType)
    {
        return container.GetAllInstances(serviceType).Cast<object>();
    }

    /// <summary>
    /// Performs application-defined tasks associated with freeing, releasing, or
    /// resetting unmanaged resources.
    /// </summary>
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    /// <summary>
    /// Destroys the instance of <see cref="StructureMapDependencyResolver"/> class.
    /// </summary>
    ~StructureMapDependencyResolver()
    {
        Dispose(false);
    }

    private void Dispose(bool disposing)
    {
        if (disposed)
            return;

        if (disposing)
        {
            container.Dispose();
            container = null;
        }

        disposed = true;
    }
}