从依赖倒置原则到IOC控制反转实现

这篇具有很好参考价值的文章主要介绍了从依赖倒置原则到IOC控制反转实现。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

从依赖倒置原则(Dependency Inversion Principle, DIP)到控制反转(Inversion of Control, IoC)再到依赖注入(Dependency Injection, DI)的演进过程,我们可以理解为一种逐步抽象和解耦的设计思想。这种思想在C#等面向对象的编程语言中得到了广泛的应用。

首先,让我们回顾一下依赖倒置原则。这个原则建议我们:

  • 高层模块不应该依赖于低层模块,二者都应该依赖于抽象。
  • 抽象不应该依赖于细节,细节应该依赖于抽象。

这个原则鼓励我们设计代码时,让高层模块与底层模块之间的依赖通过抽象(接口或基类)来进行,从而减少了模块间的耦合度。

接下来,控制反转是一种设计模式,它通过将原本由代码直接控制的对象的调用权交给第三方(如一个容器)来控制,来降低代码间的耦合度。在C#中,IoC容器是实现控制反转的一个工具。

DI是IoC的一种实现方式,它将依赖关系通过构造函数、属性或方法注入到对象中。这种方式进一步降低了代码间的耦合度,使得对象在被创建时就能获得它所需要的依赖。

现在,我们来实现一个简单的IoC容器,并通过递归完成构造函数注入。以下是一个简单的示例:

public interface IService  
{  
    void DoWork();  
}  
  
public class ConcreteService : IService  
{  
    private readonly IDependency _dependency;  
  
    public ConcreteService(IDependency dependency)  
    {  
        _dependency = dependency;  
    }  
  
    public void DoWork()  
    {  
        _dependency.DoSomething();  
    }  
}  
  
public interface IDependency  
{  
    void DoSomething();  
}  
  
public class ConcreteDependency : IDependency  
{  
    public void DoSomething()  
    {  
        Console.WriteLine("Dependency is doing something...");  
    }  
}  
  
public class SimpleIoCContainer  
{  
    private readonly Dictionary<Type, Func<object>> _registrations = new Dictionary<Type, Func<object>>();  
  
    public void Register<TService, TImplementation>() where TImplementation : TService  
    {  
        _registrations.Add(typeof(TService), () => Activator.CreateInstance(typeof(TImplementation)));  
    }  
  
    public TService Resolve<TService>()  
    {  
        if (!_registrations.ContainsKey(typeof(TService)))  
        {  
            throw new InvalidOperationException($"No registration found for {typeof(TService).FullName}");  
        }  
  
        var factory = _registrations[typeof(TService)];  
        return (TService)factory();  
    }  
  
    public object Resolve(Type serviceType)  
    {  
        if (!_registrations.ContainsKey(serviceType))  
        {  
            throw new InvalidOperationException($"No registration found for {serviceType.FullName}");  
        }  
  
        var factory = _registrations[serviceType];  
        return factory();  
    }  
}  
  
public class Program  
{  
    public static void Main()  
    {  
        var container = new SimpleIoCContainer();  
        container.Register<IService, ConcreteService>();  
        container.Register<IDependency, ConcreteDependency>();  
  
        IService service = container.Resolve<IService>();  
        service.DoWork();  
    }  
}

在这个示例中,我们定义了一个简单的IoC容器SimpleIoCContainer,它使用了一个字典来存储服务类型到工厂方法的映射。Register方法用于注册服务,而Resolve方法用于解析服务。在这个例子中,ConcreteService依赖于IDependency,IoC容器负责在创建ConcreteService实例时注入ConcreteDependency实例。

应用场景

IoC容器和依赖注入在许多场景下都非常有用,包括但不限于:

  1. 单元测试:通过IoC容器,可以轻松地替换掉生产环境中的依赖,换成用于测试的桩(Stubs)或模拟对象(Mocks),从而方便地进行单元测试。

  2. 插件架构:在需要动态加载插件的系统中,IoC容器可以用来管理插件的生命周期和依赖关系,使得插件的加载和解耦变得更加容易。

  3. 微服务:在微服务架构中,每个微服务都可以使用IoC容器来管理其内部的依赖关系,从而确保服务之间的松耦合和易于维护。

  4. 复杂的应用程序:对于大型复杂的应用程序,IoC容器可以帮助开发人员更好地组织和管理代码,降低模块间的耦合度,提高代码的可维护性和可扩展性。

  5. 跨平台开发:在需要支持多个平台或框架的应用程序中,IoC容器可以提供一个统一的依赖注入机制,使得代码更加灵活和可移植。文章来源地址https://www.toymoban.com/news/detail-856725.html

到了这里,关于从依赖倒置原则到IOC控制反转实现的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 软件设计原则:依赖倒置

    定义 依赖倒置原则(Dependency Inversion Principle, DIP)是面向对象设计原则之一,其核心是高层模块(如业务逻辑)不应当依赖于低层模块(如具体的数据访问或设备控制实现),而是双方都应依赖于抽象接口。抽象不应依赖细节,细节应依赖抽象。 应用场景 软件系统的架构设

    2024年04月09日
    浏览(64)
  • Spring5学习随笔-IOC(反转控制)、DI(依赖注入)和创建复杂对象

    学习视频:【孙哥说Spring5:从设计模式到基本应用到应用级底层分析,一次深入浅出的Spring全探索。学不会Spring?只因你未遇见孙哥】 控制:对于成员变量赋值的控制权 反转控制:把对于成员变量赋值的控制权,从代码中反转(转移)到Spring工厂和配置文件中。 好处:解耦合

    2024年02月05日
    浏览(42)
  • Spring学习笔记(二)Spring的控制反转(设计原则)与依赖注入(设计模式)

    是一种设计原则,降低程序代码之间的耦合度 对象由Ioc容器统一管理,当程序需要使用对象时直接从IoC容器中获取。这样对象的控制权就从应用程序转移到了IoC容器 依赖注入是一种消除类之间依赖关系的设计模式。例如,A类要依赖B类,A类不再直接创建B类,而是把这种依赖

    2024年02月19日
    浏览(38)
  • 【Spring进阶系列丨第二篇】Spring中的两大核心技术IoC(控制反转)与DI(依赖注入)

    我们都知道Spring 框架主要的优势是在 简化开发 和 框架整合 上,至于如何实现就是我们要学习Spring 框架的主要内容,今天我们就来一起学习Spring中的两大核心技术IoC(控制反转)与DI(依赖注入)。 以经典的三层架构MVC作为案例,以前我们都是这么干的,看如下代码: 按照

    2024年02月05日
    浏览(70)
  • Java Spring IoC&DI :探索Java Spring中控制反转和依赖注入的威力,增强灵活性和可维护性

    💓 博客主页:从零开始的-CodeNinja之路 ⏩ 收录文章:Java Spring IoCDI :探索Java Spring中控制反转和依赖注入的威力,增强灵活性和可维护性 🎉欢迎大家点赞👍评论📝收藏⭐文章 我们一下要学习的内容都是为了实现⾼内聚低耦合来进行的 软件设计原则:⾼内聚低耦合. ⾼内聚指

    2024年04月15日
    浏览(48)
  • 使用 Spring 实现控制反转和依赖注入

    在本文中,我们将介绍 IoC (控制反转)和 DI (依赖注入)的概念,以及如何在 Spring 框架中实现它们。 控制反转是软件工程中的一个原则,它将对象或程序的某些部分的控制权转移给容器或框架。我们最常在面向对象编程的上下文中使用它。 与传统编程相比,传统编程中我

    2024年02月13日
    浏览(35)
  • Spring IoC (控制反转)

    IoC 是 Inversion of Control 的简写,译为“控制反转”,它不是一门技术,而是一种设计思想,是一个重要的面向对象编程法则。 Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化,控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean,它与使

    2024年02月13日
    浏览(38)
  • Springboot 入门指南:控制反转和依赖注入的含义和实现方式

    目录 一、什么是控制反转(IoC)? 二、什么是依赖注入(DI)? 三、如何在 springboot 中使用 IoC 和 DI? 总结 控制反转(Inversion of Control,简称 IoC)是一种设计原则,它的目的是降低代码之间的耦合度,提高模块化和可测试性。控制反转的含义是,将对象的创建、配置和管理

    2024年02月11日
    浏览(44)
  • IOC控制反转--.net framework

    分层架构: 传统工艺:会有依赖,上端全部展示细节 依赖于抽象:左边依赖倒置,面向抽象 实现类继承接口,实现类实现接口的方法 左边抽象,右边实现类 BaseBll.cs (ZhaoxiFramework.BLL) 调用 第三方工厂 IPhone.cs(ZhaoxiFramework.Interface) ObjectFactory.cs(ZhaoxiFramework.IOC.Project)

    2024年02月16日
    浏览(46)
  • Go中的控制反转 IoC

    控制反转 是一种解耦思想,将原本耦合在 业务逻辑 中的 控制逻辑 单独拆出来实现,不再让 业务逻辑 在处理业务的同时还要去实现 控制逻辑 ,而是专注处理业务。在 业务逻辑 代码中耦合进 控制逻辑 ,会导致在编写业务逻辑时需要处理业务之外的事,而且 控制逻辑 耦合

    2024年03月12日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包