C＃中的依赖注入和IoC容器

最新推荐文章于 2024-06-04 21:47:17 发布

寒冰屋

最新推荐文章于 2024-06-04 21:47:17 发布

阅读量2.8k

点赞数 9

分类专栏： CSharp.NET 文章标签：依赖注入 IoC容器 c#

原文链接：https://www.codeproject.com/Articles/5274732/Dependency-Injection-and-IoC-Containers-in-Csharp

版权

CSharp.NET 专栏收录该内容

1163 篇文章 53 订阅

订阅专栏

下载源代码7.9 KB

介绍

依赖注入和IoC乍一看似乎很复杂，但是它们很容易学习和理解。

在本文中，我们将通过在C＃中重构一个非常简单的代码示例来说明依赖注入和IoC容器。

第一次尝试

我们将从创建分层架构开始。使用分层体系结构有多种好处，但是由于我们专注于依赖注入，因此我们将不在本文中列出它们。

下面是该应用程序的类图：

首先，我们将从创建一个Product类开始：

public class Product
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
}

然后，我们将创建数据访问层：

public class ProductDAL
{
    private readonly List<Product> _products;

    public ProductDAL()
    {
        _products = new List<Product>
        {
            new Product { Id = Guid.NewGuid(), Name= "iPhone 9", 
                          Description = "iPhone 9 mobile phone" },
            new Product { Id = Guid.NewGuid(), Name= "iPhone X", 
                          Description = "iPhone X mobile phone" }
        };
    }

    public IEnumerable<Product> GetProducts()
    {
        return _products;
    }

    public IEnumerable<Product> GetProducts(string name)
    {
        return _products
            .Where(p => p.Name.Contains(name))
            .ToList();
    }
}

然后，我们将创建业务层：

public class ProductBL
{
    private readonly ProductDAL _productDAL;

    public ProductBL()
    {
        _productDAL = new ProductDAL();
    }

    public IEnumerable<Product> GetProducts()
    {
        return _productDAL.GetProducts();
    }

    public IEnumerable<Product> GetProducts(string name)
    {
        return _productDAL.GetProducts(name);
    }
}

最后，我们将创建UI：

class Program
{
    static void Main(string[] args)
    {
        ProductBL productBL = new ProductBL();

        var products = productBL.GetProducts();

        foreach (var product in products)
        {
            Console.WriteLine(product.Name);
        }

        Console.ReadKey();
    }
}

我们在第一次尝试中编写的代码可以正常工作，但是有一些问题：

我们不能在每个层上有三个不同的团队一起工作。
业务层很难扩展，因为它依赖于数据访问层的实现。
业务层难以维护，因为它依赖于数据访问层的实现。
源代码很难测试。

IoC容器

容器仅仅是有助于实现依赖注入的东西。容器通常实现三种不同的功能：

注册接口和接口的具体实现之间的映射
创建对象并解决依赖关系
释放

让我们实现一个简单的容器来注册映射以及创建对象。

首先，我们需要一个存储映射的数据结构。我们将选择Hashtable。该数据结构将存储映射。

首先，我们将在Container的构造函数中初始化Hashtable。然后，我们将创建一个注册映射的RegisterTransient方法。最后，我们将创建一个将创建对象的Create方法：

public class Container
{
    private readonly Hashtable _registrations;

    public Container()
    {
        _registrations = new Hashtable();
    }

    public void RegisterTransient<TInterface, TImplementation>()
    {
        _registrations.Add(typeof(TInterface), typeof(TImplementation));
    }

    public TInterface Create<TInterface>()
    {
        var typeOfImpl = (Type)_registrations[typeof(TInterface)];
        if (typeOfImpl == null)
        {
            throw new ApplicationException($"Failed to resolve {typeof(TInterface).Name}");
        }
        return (TInterface)Activator.CreateInstance(typeOfImpl);
    }
}

最后，我们必须更新UI：

class Program
{
    static void Main(string[] args)
    {
        var container = new Container();
        container.RegisterTransient<IProductDAL, ProductDAL>();

        IProductBL productBL = new ProductBL(container.Create<IProductDAL>());
        var products = productBL.GetProducts();

        foreach (var product in products)
        {
            Console.WriteLine(product.Name);
        }

        Console.ReadKey();
    }
}

现在，让我们在容器中实现Resolve方法。此方法将解决依赖关系。

下面是Resolve方法：

public T Resolve<T>()
{
    var ctor = ((Type)_registrations[typeof(T)]).GetConstructors()[0];
    var dep = ctor.GetParameters()[0].ParameterType;
    var mi = typeof(Container).GetMethod("Create");
    var gm = mi.MakeGenericMethod(dep);
    return (T)ctor.Invoke(new object[] { gm.Invoke(this, null) });
}

然后，我们可以在UI中使用如下Resolve方法：

class Program
{
    static void Main(string[] args)
    {
        var container = new Container();
        container.RegisterTransient<IProductDAL, ProductDAL>();
        container.RegisterTransient<IProductBL, ProductBL>();

        var productBL = container.Resolve<IProductBL>();
        var products = productBL.GetProducts();

        foreach (var product in products)
        {
            Console.WriteLine(product.Name);
        }

        Console.ReadKey();
    }
}

在上面的源代码中，容器使用container.Resolve<IProductBL>()方法创建了一个ProductBL类对象。ProductBL类依赖于IProductDAL。因此，container.Resolve<IProductBL>()通过自动创建并在其中注入一个ProductDAL对象来返回ProductBL类的一个对象。所有这些都在幕后。创建和注入ProductDAL对象是因为我们用IProductDAL注册了ProductDAL类型。

这是一个非常简单且基本的IoC容器，向您展示IoC容器背后的内容。您可以在.NET源代码中使用多个IoC容器。

寒冰屋

关注

9
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
C＃中的依赖注入和IoC容器

目录介绍要求第一次尝试第二次尝试最终尝试IoC容器下载源代码7.9 KB介绍依赖注入和IoC乍一看似乎很复杂，但是它们很容易学习和理解。在本文中，我们将通过在C＃中重构一个非常简单的代码示例来说明依赖注入和IoC容器。要求构建一个允许用户查看可用产品并按名称搜索产品的应用程序。第一次尝试我们将从创建分层架构开始。使用分层体系结构有多种好处，但是由于我们专注于依赖注入，因此我们将不在本文中列出它们。下面是该应用程序的类图：首先，我们将从创建
复制链接

扫一扫