C# 接口与依赖反转

已于 2022-02-17 17:08:09 修改
阅读量530 收藏 1
点赞数 1
文章标签： c# linq 开发语言
于 2022-02-17 16:32:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helldoger/article/details/122985229
版权

一个小例子:

using System;

namespace IndependenceReverseTest1
{
    class Program
    {
        static void Main(string[] args)
        {
            //通过传入不同的对象new PowerSupply() 与 new BadPowerSupply()
            //DeskFan 中的IpowerSupply _powerSupply 可以实现不同的方法
            //DeskFan 的构造函数也是IpowerSupply 类型, 可以传入继承IpowerSupply的一切方法
            var test1 = new DeskFan(new PowerSupply());
            var test2 = new DeskFan(new BadPowerSupply());
            Console.WriteLine(test1.Work());
            Console.WriteLine("--------------------");
            Console.WriteLine(test2.Work());
            Console.ReadKey();
        }

        interface IpowerSupply
        {
            int GetPower();
        }


        class PowerSupply : IpowerSupply
        {
            public int GetPower()
            {
                return 100;
            }
        }

        class BadPowerSupply : IpowerSupply
        {
            public int GetPower()
            {
                return 500;
            }
        }

        class DeskFan
        {
            private IpowerSupply _powerSupply;

            public DeskFan(IpowerSupply powerSupply)
            {
                _powerSupply = powerSupply;
            }

            public string Work()
            {
                int power = _powerSupply.GetPower();
                if (power <= 0)
                {
                    return "Can not work!";
                }
                else if (power < 100)
                {
                    return "Slow!";
                }
                else if (power < 200)
                {
                    return "Work fine!";
                }
                else
                {
                    return "FBI Waring!";
                }
            }
        }
    }
}

举例说明: 实际应用中, 现在有2张表, CargoType和Member:

//------------------------------------------------------------------------------
// <auto-generated>
//     此代码已从模板生成。
//
//     手动更改此文件可能导致应用程序出现意外的行为。
//     如果重新生成代码，将覆盖对此文件的手动更改。
// </auto-generated>
//------------------------------------------------------------------------------

namespace CMS.Models
{
    using System;
    using System.Collections.Generic;
    
    public partial class CargoType
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Tag { get; set; }
        public System.DateTime InsertDate { get; set; }
        public int MemberId { get; set; }
        public string MemberName { get; set; }
    }
}


//------------------------------------------------------------------------------
// <auto-generated>
//     此代码已从模板生成。
//
//     手动更改此文件可能导致应用程序出现意外的行为。
//     如果重新生成代码，将覆盖对此文件的手动更改。
// </auto-generated>
//------------------------------------------------------------------------------

namespace CMS.Models
{
    using System;
    using System.Collections.Generic;
    
    public partial class Member
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Password { get; set; }
        public int Role { get; set; }
        public System.DateTime InsertDate { get; set; }
    }
}

使用常规方法, 使用EntityFramework和接口实现数据库CRUD

建立IProvider接口:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Models
{
    /// <summary>
    /// 接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IProvider<T> where T : class
    {
        /// <summary>
        /// 查询所有记录
        /// </summary>
        /// <returns></returns>
        List<T> Select();

        /// <summary>
        /// 插入一条记录
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        int Insert(T t);

        /// <summary>
        /// 修改一条记录
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        int Update(T t);

        /// <summary>
        /// 删除一条记录
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        int Delete(T t);
    }
}

建立CargoTypeProvider

using CMS.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Models
{
    //alt + enter
    public class CargoTypeProvider : IProvider<CargoType>
    {
        private CargoEntities db = new CargoEntities();

        public int Delete(CargoType t)
        {
            if (t == null) return 0;
            var model = db.CargoType.ToList().FirstOrDefault(item => t.Id == item.Id);
            if (model == null) return 0;
            db.CargoType.Remove(model);
            int count = db.SaveChanges();
            return count;
        }

        public int Insert(CargoType t)
        {
            if (t == null) return 0;
            if (string.IsNullOrEmpty(t.Name)||string.IsNullOrEmpty(t.MemberName)) return 0;
            if (t.InsertDate == null) return 0;
            db.CargoType.Add(t);
            int count = db.SaveChanges();
            return count;
        }

        public List<CargoType> Select()
        {
            return db.CargoType.ToList();
        }

        public int Update(CargoType t)
        {
            if (t == null) return 0;
            return 0;
        }
    }
}

Member Provider:

using CMS.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Models
{
    public class MemberProvider : IProvider<Member>
    {
        private CargoEntities db = new CargoEntities();
        public int Delete(Member t)
        {
            if (t == null) return 0;
            var model = db.Member.ToList().FirstOrDefault(item => item.Id == t.Id);
            if (model != null)
            {
                db.Member.Remove(model);
                return db.SaveChanges();
            }
            return 0;
        }

        public int Insert(Member t)
        {
            if (t == null) return 0;
            db.Member.Add(t);
            return db.SaveChanges();
        }

        public List<Member> Select()
        {
            return db.Member.ToList();
        }

        public int Update(Member t)
        {
            if (t == null) return 0;
            var model = db.Member.ToList().FirstOrDefault(item => item.Id == t.Id);
            if (model != null)
            {
                model.Password = t.Password;
                model.Role = t.Role;
                int count = db.SaveChanges();
                return count;
            }
            return 0;
        }
    }
}

如果使用依赖反转的思想:

建立IProvider1:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMS.Models2
{
    public interface IProvider1
    {
        void Select();
        void Insert();
        void Update();
        void Delete();
    }
}

建立CargoTypeProvider1与MemberProvider1

using CMS.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMS.Models2
{
    class CargoTypeProvider1 : IProvider1
    {
        private CargoEntities db = new CargoEntities();

        //接收增删改 成功/失败
        private int _count;

        public int Count { get => _count; set => _count = value; }
        
        //接收查询结果
        List<CargoType> _cargoTypes;

        public List<CargoType> CargoTypes { get => _cargoTypes; set => _cargoTypes = value; }

        //接收外部输入对象
        private CargoType _t;

        public CargoTypeProvider1(CargoType t)
        {
            _t = t;
        }

        public CargoTypeProvider1()
        {
        }

        public void Delete()
        {
            if (_t == null) _count = 0;
            var model = db.CargoType.ToList().FirstOrDefault(item => _t.Id == item.Id);
            if (model == null) _count = 0;
            db.CargoType.Remove(model);
            int count = db.SaveChanges();
            _count = count;
        }

        public void Insert()
        {
            if (_t == null) _count = 0;
            if (string.IsNullOrEmpty(_t.Name) || string.IsNullOrEmpty(_t.MemberName)) _count = 0;
            if (_t.InsertDate == null) _count = 0;
            db.CargoType.Add(_t);
            int count = db.SaveChanges();
            _count = count;
        }

        public void Select()
        {
            _cargoTypes = db.CargoType.ToList();
        }

        public void Update()
        {
            if (_t == null) _count = 0;
            var model = db.CargoType.ToList().FirstOrDefault(item => _t.Id == item.Id);
            if (model == null) _count = 0;
            model.MemberName = _t.MemberName;
            model.Name = _t.Name;
            model.Tag = _t.Tag;
            model.MemberId = _t.MemberId;
            int count = db.SaveChanges();
            _count = count;
        }
    }
}


using CMS.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMS.Models2
{
    public class MemberProvider1 : IProvider1
    {
        private CargoEntities db = new CargoEntities();

        private int _count;

        public int Count { get => _count; set => _count = value; }

        private List<Member> _members;

        public List<Member> Members { get => _members; set => _members = value; }

        //接收外部数据
        private Member _t;

        public MemberProvider1(Member t)
        {
            _t = t;
        }

        public MemberProvider1()
        {
        }



        public void Delete()
        {
            if (_t == null) _count = 0;
            var model = db.Member.ToList().FirstOrDefault(item => _t.Id == item.Id);
            if (model == null) _count = 0;
            db.Member.Remove(model);
            int count = db.SaveChanges();
            _count = count;
        }

        public void Insert()
        {
            if (_t == null) _count = 0;
            if (_t.InsertDate == null) _count = 0;
            db.Member.Add(_t);
            int count = db.SaveChanges();
            _count = count;
        }

        public void Select()
        {
            Members = db.Member.ToList();
        }

        public void Update()
        {
            if (_t == null) _count = 0;
            var model = db.Member.ToList().FirstOrDefault(item => _t.Id == item.Id);
            if (model == null) _count = 0;
            model.Role = _t.Role;
            model.Name = _t.Name;
            model.Password = _t.Password;
            int count = db.SaveChanges();
            _count = count;
        }
    }
}

建立UserProvider,再次封装, 统一调用, 只需要将MemberProvider1 或者 CargoTypeProvider1 输入 UserProvider, 由于接口为父类, 可以实现方法的多态化.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMS.Models2
{
    public class UserProvider
    {
        private IProvider1 _provider1;

        public UserProvider(IProvider1 provider1)
        {
            _provider1 = provider1;
        }

        public void Delete()
        {
            _provider1.Delete();
        }

        public void Select()
        {
            _provider1.Select();
        }

        public void Update()
        {
            _provider1.Update();
        }

        public void Insert()
        {
            _provider1.Insert();
        }
    }
}

测试 :

using CMS.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CMS.Models2
{
    public class Test1
    {
        public Test1(CargoType t)
        {
            var t1 = new UserProvider(new CargoTypeProvider1(t));
            //增删改
            t1.Insert();
            t1.Delete();
            t1.Update();
            //查询
            List<CargoType> cargoSelect = new CargoTypeProvider1().CargoTypes;
        }

        public Test1(Member t)
        {
            var t2 = new UserProvider(new MemberProvider1(t));
            t2.Insert();
            t2.Delete();
            t2.Update();

            List<Member> memberSelct = new MemberProvider1().Members;
        }

    }
}

接口隔离:

using System;

namespace DependencyInjection
{
    class Program
    {
        static void Main(string[] args)
        {
            var driver = new Driver(new HeavyTank());
            driver.Drive();
            //接口隔离的好处就是, 有选择性的继承对象的一部分属性
            //在这里, driver并没有Fire方法, 只有Diver()
            var dv1 = driver as ITank;
            dv1.Fire();
            //此处的dv1 有了Fire() 因为传进来的HeavyTank 继承了 ITank, 而ITank继承了IWeapon
            var dv2 = (ITank)driver;
            dv2.Fire();
            //此处的dv2 也有了Fire()
            Console.ReadKey();
        }
    }

    class Driver
    {
        private IVehicle _vehicle; //此处使用了接口隔离, 
        public Driver(IVehicle vehicle)
        {
            _vehicle = vehicle;
        }

        public void Drive()
        {
            _vehicle.Run();
        }
    }

    interface IVehicle
    {
        public void Run();
    }

    interface IWeapon
    {
        public void Fire();
    }
    interface ITank:IVehicle,IWeapon
    {

    }

    //interface ITank
    //{
    //    void Fire();
    //    void Run();
    //}

    class Car : IVehicle
    {
        public void Run()
        {
            Console.WriteLine("Car is running");
        }
    }

    class Truck : IVehicle
    {
        public void Run()
        {
            Console.WriteLine("Truck is running");
        }
    }




    class LightTank : ITank
    {
        public void Fire()
        {
            Console.WriteLine("Boom!");
        }

        public void Run()
        {
            Console.WriteLine("Ka ka ka!");
        }
    }

    class MediumTank : ITank
    {
        public void Fire()
        {
            Console.WriteLine("Boom!!");
        }

        public void Run()
        {
            Console.WriteLine("Ka ka ka!!");
        }
    }

    class HeavyTank : ITank
    {
        public void Fire()
        {
            Console.WriteLine("Boom!!!");
        }

        public void Run()
        {
            Console.WriteLine("Ka ka ka!!!");
        }
    }


}
C# 实例解释面向对象编程中的依赖反转原则
「 虚幻私塾」
07-26 328
本文我介绍了SOLID原则中的依赖反转原则（Dependencyinversionprinciple），并通过C#代码示例简明地诠释了它的含意和实现，希望对您有所帮助。作者技术译民出品技术译站httpshttpshttpshttps。
2021-06-26-刘铁猛C#语言入门详解-学习笔记P28接口、依赖反转、单元测试
weixin_49079904的博客
06-26 531
P28接口、依赖反转、单元测试 一、P28内容总结 接口 依赖与耦合 依赖反转原则（SOLID中的D） 单元测试 二、接口：服务的提供者实现接口，服务的消费者引用接口 //实例：对一组整数进行求和与求平均值的操作 //这组整数可能存于数组也可能存于ArrayList里 方法一：不使用接口时 using System; using System.Collections;//为引入ArrayList namespace ConsoleApp3 { class Program {
C#依赖 依赖反转
最新发布
weixin_61884921的博客
02-16 1382
我们先来看这张图，Driver，Trucker，Racer三个类中均包含了他们所驾驶的专门车辆的类Car、Truck、RaceCar。驾驶员类这三个类的Drive方法是与车辆类密切相关的，也就是说脱离了这三个车辆类，驾驶员类无法正常使用，这就是我们常说的依赖，我们的驾驶员类依赖于车辆类 （请注意根据类的实际情况确认类与类的实际依赖关系）。我们来通过一段代码加深对依赖的理解，首先创建一个引擎类} //引擎转速//引擎转速等于1000 x gas。
C# 之 利用接口实现依赖反转
浪子花梦
07-26 761
当我们在一个类中定义另一个类时，这就形成了耦合，通过具体的逻辑这种耦合可大可小，我们可以利用接口来解除这种不必要的耦合性，如下所示，这是没有使用接口的情况： class Car { public void SayHello() { Console.WriteLine("Hello, I'm is Car!!!"); } } class Truck { public void SayHello() { Console.WriteLine
c# 依赖注入 控制反转
08-14
控制反转 依赖注入的c#实现，很好的教程。
《软件架构之道》c#实现依赖反转
05-10 168
接口定义了模块的行为，而不是实现细节，这样高层模块就可以依赖接口，而不是依赖具体的实现。依赖注入是一种将依赖关系从代码中移除的技术，它允许组件在运行时通过构造函数或属性来接收依赖项，而不是在组件内部创建它们。在上面的代码中，我们使用依赖反转原则，将 Document 类从具体的 Printer 类解耦，使得我们可以在运行时动态地替换打印机实现，从而使代码更加灵活和可扩展。通过应用依赖反转原则，可以提高代码的可维护性和可测试性，因为它使得代码更容易进行修改和扩展，而不需要修改其他部分的代码。
C# 实践：控制反转与依赖注入详解
"本文介绍了C#中的依赖注入和控制反转（IoC）概念，以及如何在C#应用程序中实现这些概念。通过示例代码展示了传统的控制流程，并对比了使用依赖注入后的变化，帮助读者理解反转控制的概念。" 在软件设计中，控制...
C#学习笔记 接口，依赖反转，单元测试
Mr_Tfos的博客
04-14 225
接口与单元测试 接口的产生：自底向上（重构），自顶向下（设计） C#中接口的实现（隐式，显式，多接口） 语言对面向对象设计的内建支持：依赖反转，接口隔离，开/闭原则…… 对存储在整型数组ArrayList里的整数进行求和、求平均值。 1.在不使用接口的情况下，需要写4个函数。因为C#语言是强类型语言，用来操作整型数组的函数，是不能操作ArrayList实例的。在没有使用接口/契约的情况下，是非常不方便的。 static void Main(string[] args) {
《C#入门详解》刘铁猛——Lesson29-30接口、依赖反转、接口隔离、反射、特性、依赖注入
zhang_amanda的博客
08-17 723
29-30
C# 控制反转（Inversion of Control，缩写为IoC）依赖关系反转
cgs的博客
01-01 793
依赖关系反转 应用程序中的依赖关系方向应该是抽象的方向，而不是实现详细信息的方向。 大部分应用程序都是这样编写的：编译时依赖关系顺着运行时执行的方向流动，从而生成一个直接依赖项关系图。 也就是说，如果模块 A 调用模块 B 中的函数，而模块 B 又调用模块 C 中的函数，则编译时 A 取决于 B，而 B 又取决于 C，如下图所示： 应用依赖关系反转原则后，A 可以调用 B 实现的抽象上的方法，让 A 可以在运行时调用 B，而 B 又在编译时依赖于 A 控制的接口（因此，典型的编译时依赖项发生反转）。 运行
C#学习笔记（二十三）接口、依赖反转、单元测试
xiaoyaolangwj的博客
04-16 336
接口与抽象类 接口由抽象类进化而来。 抽象类的方法要求不是private，接口类的成员方方法要求一定必须是public，默认都不让写。 接口的本质：服务的消费者或服务的调用者，与服务的提供者之间的契约。契约：对合同的双方都是可见的。所以用public。 而抽象类的protected成员只是留给子类所看到的。 契约：使自由合作成为可能：即约束服务方，又约束使用方。 接口引入历程： 对一组整数求和求平均值。 这组数据可能放在一个int类型的数组中，也可能放在一个ArrayList集合（非泛型
C#控制台依赖反转
速冻的博客
06-10 186
简单点 以下例子是一个接口 实例化为一个继承它的方法 role类 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace CMSJ { class Role { public IMyInterface MyInterface { get; set; } publ
C#学习（14）---接口、依赖反转、单元测试、接口隔离原则
m0_62976227的博客
12-23 781
从上节课来看，接口跟纯虚抽象类其实本质上很相似，可以说一模一样。所以接下来的过程中，请不要忘记，接口也是“类”，也可以声明变量，引用实例。 接口从现实意义的角度来看，像是一种“协议”“契约”，是建立在使用者和提供者之间的。对于使用者，它规定了，“我想要什么”“我能要什么”；对于提供者，它规定了“你可以给出什么”。由于接口是契约，故它必须对双方透明公开，对合同双方可见，即接口一定是public的。 本节课讲了接口的三层面/方面作用。下面逐一讲解。 第一个作用，接口发挥“契约”作用，减少重复代码： u
【C#】依赖反转，依赖注入，反射之间的关系？
qq_53045580的博客
06-09 450
依赖反转？依赖注入？反射？特此学习并记录一下自己浅显的理解。依赖反转是一种设计模式的原则，依赖注入是一种具体实现方式，都是为了降低耦合性。反射可以用于实现依赖注入。
C#之依赖倒置
qq_43473249的博客
03-21 352
namespace _3月18号 { //abstract class Couse //{ // public abstract void show(); //} //class JavaCouse : Couse //{ // public override void show() // { // ...
C#依赖注入 控制反转（笔记）
weixin_42690280的博客
04-15 443
1.MEF组件应用： 引用库： using System.ComponentModel.Composition; using System.ComponentModel.Composition.Hosting; 接口： interface IService { void Function(); } 接口实现(Export中第一个参数为自己命名名称，第二个参数为接口的type)： using System.ComponentModel.Compositi...
C#源代码生成器深入讲解一
博客
11-10 3544
源代码生成器系统深入讲解，第一篇
Entity Framework之问题收集
weixin_30471561的博客
06-15 121
本节讨论内容主要针对收集了上篇文章大家碰到问题的讨论解决，会持续收集扩充。 DbContext加载原值，当前值，数据库值，属性操作，对象复制，对象值复制（VO，DTO->POCO），复杂对象取值 DbContext Local Data与AsNoTracking无跟踪查询 如何提高效率 DbContext如何关闭延迟加载 DbContext如可使用延迟加载 DbContext如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘诺西亚的火山

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值