ASP.NET Web API 2 ' de bağımlılık eklemeDependency Injection in ASP.NET Web API 2

, Mike te sonby Mike Wasson

Tamamlanmış projeyi indirDownload Completed Project

Bu öğreticide, ASP.NET Web API denetleyicinize bağımlılık ekleme gösterilmektedir.This tutorial shows how to inject dependencies into your ASP.NET Web API controller.

Öğreticide kullanılan yazılım sürümleriSoftware versions used in the tutorial

Bağımlılık ekleme nedir?What is Dependency Injection?

Bağımlılık , başka bir nesnenin gerektirdiği herhangi bir nesnedir.A dependency is any object that another object requires. Örneğin, veri erişimini işleyen bir Depo tanımlanması yaygındır.For example, it's common to define a repository that handles data access. Bir örnekle bakalım.Let's illustrate with an example. İlk olarak, bir etki alanı modeli tanımlayacağız:First, we'll define a domain model:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

İşte, Entity Framework kullanarak bir veritabanındaki öğeleri depolayan basit bir depo sınıfı.Here is a simple repository class that stores items in a database, using Entity Framework.

public class ProductsContext : DbContext
{
    public ProductsContext()
        : base("name=ProductsContext")
    {
    }
    public DbSet<Product> Products { get; set; }
}

public class ProductRepository : IDisposable
{
    private ProductsContext db = new ProductsContext();

    public IEnumerable<Product> GetAll()
    {
        return db.Products;
    }
    public Product GetByID(int id)
    {
        return db.Products.FirstOrDefault(p => p.Id == id);
    }
    public void Add(Product product)
    {
        db.Products.Add(product);
        db.SaveChanges();
    }

    protected void Dispose(bool disposing)
    {
        if (disposing)
        {
            if (db != null)
            {
                db.Dispose();
                db = null;
            }
        }
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

Şimdi varlıklar için GET isteklerini destekleyen bir Web API denetleyicisi tanımlayalim Product .Now let's define a Web API controller that supports GET requests for Product entities. (Basitlik için GÖNDERI ve diğer yöntemleri dışarıda bırakıyorum.) İlk deneme aşağıda verilmiştir:(I'm leaving out POST and other methods for simplicity.) Here is a first attempt:

public class ProductsController : ApiController
{
    // This line of code is a problem!
    ProductRepository _repository = new ProductRepository();

    public IEnumerable<Product> Get()
    {
        return _repository.GetAll();
    }

    public IHttpActionResult Get(int id)
    {
        var product = _repository.GetByID(id);
        if (product == null)
        {
            return NotFound();
        }
        return Ok(product);
    }
}

Denetleyici sınıfının bağlı olduğuna ProductRepository ve denetleyicinin örneği oluşturmasına izin verdiğine dikkat edin ProductRepository .Notice that the controller class depends on ProductRepository, and we are letting the controller create the ProductRepository instance. Bununla birlikte, birkaç nedenden dolayı bağımlılığı bu şekilde sabit olarak kodladığı için kötü bir fikir olabilir.However, it's a bad idea to hard code the dependency in this way, for several reasons.

  • ProductRepositoryFarklı bir uygulamayla değiştirmek istiyorsanız, denetleyici sınıfını da değiştirmeniz gerekir.If you want to replace ProductRepository with a different implementation, you also need to modify the controller class.
  • , ProductRepository Bağımlılıkları varsa, bunları denetleyicinin içinde yapılandırmanız gerekir.If the ProductRepository has dependencies, you must configure these inside the controller. Birden çok denetleyici içeren büyük bir proje için yapılandırma kodunuz projenize dağılmış hale gelir.For a large project with multiple controllers, your configuration code becomes scattered across your project.
  • Denetleyici, veritabanını sorgulamak için sabit kodlanmış olduğundan, birim testi zordur.It is hard to unit test, because the controller is hard-coded to query the database. Birim testi için, geçerli tasarımla mümkün olmayan bir sahte veya saplama deposu kullanmanız gerekir.For a unit test, you should use a mock or stub repository, which is not possible with the current design.

Bu sorunları, depoyu denetleyiciye ekleme göre ele alabilir.We can address these problems by injecting the repository into the controller. İlk olarak, ProductRepository sınıfı bir arabirim olarak yeniden düzenleyin:First, refactor the ProductRepository class into an interface:

public interface IProductRepository
{
    IEnumerable<Product> GetAll();
    Product GetById(int id);
    void Add(Product product);
}

public class ProductRepository : IProductRepository
{
    // Implementation not shown.
}

Sonra da IProductRepository bir oluşturucu parametresi olarak belirtin:Then provide the IProductRepository as a constructor parameter:

public class ProductsController : ApiController
{
    private IProductRepository _repository;

    public ProductsController(IProductRepository repository)  
    {
        _repository = repository;
    }

    // Other controller methods not shown.
}

Bu örnek, Oluşturucu Eklemekullanır.This example uses constructor injection. Ayrıca, bir ayarlayıcı yöntemi veya özelliği aracılığıyla bağımlılığı ayarladığınız ayarlayıcı eklemeözelliğini de kullanabilirsiniz.You can also use setter injection, where you set the dependency through a setter method or property.

Ancak artık, uygulamanız denetleyiciyi doğrudan oluşturmadığından bir sorun oluştu.But now there is a problem, because your application doesn't create the controller directly. Web API 'SI isteği yönlendirdiğinizde denetleyiciyi oluşturur ve Web API 'SI hakkında hiçbir şey bilmez IProductRepository .Web API creates the controller when it routes the request, and Web API doesn't know anything about IProductRepository. Bu, Web API bağımlılığı Çözümleyicisinin geldiği yerdir.This is where the Web API dependency resolver comes in.

Web API bağımlılığı ÇözümleyicisiThe Web API Dependency Resolver

Web API 'SI, bağımlılıkları çözümlemek için ıdependencyresolver arabirimini tanımlar.Web API defines the IDependencyResolver interface for resolving dependencies. Arabirimin tanımı şöyledir:Here is the definition of the interface:

public interface IDependencyResolver : IDependencyScope, IDisposable
{
    IDependencyScope BeginScope();
}

public interface IDependencyScope : IDisposable
{
    object GetService(Type serviceType);
    IEnumerable<object> GetServices(Type serviceType);
}

IDependencyScope arabirimi iki yönteme sahiptir:The IDependencyScope interface has two methods:

  • GetService bir türün bir örneğini oluşturur.GetService creates one instance of a type.
  • GetServices , belirtilen türde nesnelerin bir koleksiyonunu oluşturur.GetServices creates a collection of objects of a specified type.

Idependencyresolver yöntemi IDependencyScope devralır ve BeginScope metodunu ekler.The IDependencyResolver method inherits IDependencyScope and adds the BeginScope method. Bu öğreticide daha sonra kapsamlar hakkında konuşacağız.I'll talk about scopes later in this tutorial.

Web API 'SI bir denetleyici örneği oluşturduğunda, önce denetleyici türünü geçirerek ıdependencyresolver. GetServiceöğesini çağırır.When Web API creates a controller instance, it first calls IDependencyResolver.GetService, passing in the controller type. Bu genişletilebilirlik kancasını, denetleyiciyi oluşturmak ve tüm bağımlılıkları çözmek için kullanabilirsiniz.You can use this extensibility hook to create the controller, resolving any dependencies. GetService null döndürürse, Web API 'si denetleyici sınıfında parametresiz bir oluşturucu arar.If GetService returns null, Web API looks for a parameterless constructor on the controller class.

Unity kapsayıcısı ile bağımlılık çözümlemesiDependency Resolution with the Unity Container

Sıfırdan tamamlanmış bir ıdependencyresolver uygulaması yazabilseniz de, arabirim aslında Web API 'si ve var olan IOC kapsayıcıları arasında köprü olarak çalışacak şekilde tasarlanmıştır.Although you could write a complete IDependencyResolver implementation from scratch, the interface is really designed to act as bridge between Web API and existing IoC containers.

Bir IOC kapsayıcısı, bağımlılıkları yönetmekten sorumlu bir yazılım bileşenidir.An IoC container is a software component that is responsible for managing dependencies. Türleri kapsayıcıya kaydeder ve sonra nesneleri oluşturmak için kapsayıcıyı kullanın.You register types with the container, and then use the container to create objects. Kapsayıcı, bağımlılık ilişkilerini otomatik olarak belirler.The container automatically figures out the dependency relations. Birçok IOC kapsayıcısı ayrıca nesne ömrü ve kapsamı gibi şeyleri denetlemenize olanak tanır.Many IoC containers also allow you to control things like object lifetime and scope.

Note

"IoC", bir çerçevenin uygulama koduna çağırdığı genel bir model olan "denetimin INVERSION" anlamına gelir."IoC" stands for "inversion of control", which is a general pattern where a framework calls into application code. Bir IOC kapsayıcısı, nesnelerinizi sizin için oluşturur, bu da normal denetim akışını "tersine çevirir".An IoC container constructs your objects for you, which "inverts" the usual flow of control.

Bu öğretici için, Microsoft düzenleri uygulamalarından Unity kullanacağız & .For this tutorial, we'll use Unity from Microsoft Patterns & Practices. (Diğer popüler kitaplıklar, role Spring.net, Autofac, neklemesineve StructureMapiçerir.) Unity 'yi yüklemek için NuGet paket yöneticisini kullanabilirsiniz.(Other popular libraries include Castle Windsor, Spring.Net, Autofac, Ninject, and StructureMap.) You can use NuGet Package Manager to install Unity. Visual Studio 'daki Araçlar menüsünde, NuGet Paket Yöneticisi' ni ve ardından Paket Yöneticisi konsolu' nu seçin.From the Tools menu in Visual Studio, select NuGet Package Manager, then select Package Manager Console. Paket Yöneticisi konsolu penceresinde aşağıdaki komutu yazın:In the Package Manager Console window, type the following command:

Install-Package Unity

Bir Unity kapsayıcısını sarmalayan ıdependencyresolver 'ın bir uygulaması aşağıda verilmiştir.Here is an implementation of IDependencyResolver that wraps a Unity container.

using Microsoft.Practices.Unity;
using System;
using System.Collections.Generic;
using System.Web.Http.Dependencies;

public class UnityResolver : IDependencyResolver
{
    protected IUnityContainer container;

    public UnityResolver(IUnityContainer container)
    {
        if (container == null)
        {
            throw new ArgumentNullException(nameof(container));
        }
        this.container = container;
    }

    public object GetService(Type serviceType)
    {
        try
        {
            return container.Resolve(serviceType);
        }
        catch (ResolutionFailedException exception)
        {
            throw new InvalidOperationException(
                $"Unable to resolve service for type {serviceType}.",
                exception)
        }
    }

    public IEnumerable<object> GetServices(Type serviceType)
    {
        try
        {
            return container.ResolveAll(serviceType);
        }
        catch (ResolutionFailedException exception)
        {
            throw new InvalidOperationException(
                $"Unable to resolve service for type {serviceType}.",
                exception)
        }
    }

    public IDependencyScope BeginScope()
    {
        var child = container.CreateChildContainer();
        return new UnityResolver(child);
    }

    public void Dispose()
    {
        Dispose(true);
    }

    protected virtual void Dispose(bool disposing)
    {
        container.Dispose();
    }
}

Bağımlılık çözümleyici 'yi yapılandırmaConfiguring the Dependency Resolver

Genel HttpConfiguration nesnesinin dependencyresolver özelliğinde bağımlılık çözümleyici 'yi ayarlayın.Set the dependency resolver on the DependencyResolver property of the global HttpConfiguration object.

Aşağıdaki kod, IProductRepository arabirimi Unity ile kaydeder ve sonra bir oluşturur UnityResolver .The following code registers the IProductRepository interface with Unity and then creates a UnityResolver.

public static void Register(HttpConfiguration config)
{
    var container = new UnityContainer();
    container.RegisterType<IProductRepository, ProductRepository>(new HierarchicalLifetimeManager());
    config.DependencyResolver = new UnityResolver(container);

    // Other Web API configuration not shown.
}

Bağımlılık kapsamı ve denetleyici ömrüDependency Scope and Controller Lifetime

Denetleyiciler istek başına oluşturulur.Controllers are created per request. Idependencyresolver nesne ömrünü yönetmek için bir kapsamınkavramını kullanır.To manage object lifetimes, IDependencyResolver uses the concept of a scope.

HttpConfiguration nesnesine eklenen bağımlılık Çözümleyicisi genel kapsama sahip.The dependency resolver attached to the HttpConfiguration object has global scope. Web API 'SI bir denetleyici oluşturduğunda, BeginScope'u çağırır.When Web API creates a controller, it calls BeginScope. Bu yöntem, bir alt kapsamı temsil eden bir IDependencyScope döndürür.This method returns an IDependencyScope that represents a child scope.

Daha sonra Web API 'SI, denetleyiciyi oluşturmak için alt kapsamdaki GetService 'i çağırır.Web API then calls GetService on the child scope to create the controller. İstek tamamlandığında, Web API 'SI alt kapsamda Dispose çağırır.When request is complete, Web API calls Dispose on the child scope. Denetleyicinin bağımlılıklarını atmak için Dispose yöntemini kullanın.Use the Dispose method to dispose of the controller's dependencies.

BeginScope 'ı nasıl uygulayacağınızı IOC kapsayıcısına göre değişir.How you implement BeginScope depends on the IoC container. Unity için, kapsam bir alt kapsayıcıya karşılık gelir:For Unity, scope corresponds to a child container:

public IDependencyScope BeginScope()
{
    var child = container.CreateChildContainer();
    return new UnityResolver(child);
}

Çoğu IOC kapsayıcısının benzer eşdeğerleri vardır.Most IoC containers have similar equivalents.