c#之接口，依赖反转，单元测试

1.接口 

弱类型语言允许将一块内存看做多种类型。比如直接将整型变量与字符变量相加。C and C++ 是静态语言，也是弱类型语言；Perl and PHP 是动态语言，但也是弱类型语言。 
强类型语言在没有强制类型转化前，不允许两种不同类型的变量相互操作。Java、C# 和 Python 等都是强类型语言。

下面代码简单介绍了使用接口的例子，因为c#是强类型语言，所以如果Sum()方法的参数不是IEnumerable的话，就只能是int[]或者ArryList，这种情况下，如果想num与arrayList对象都用sum和avg方法的话就得每个都写一遍，但是因为数组和ArrayList都继承了IEnumerable，所以可以直接用它做参数接收。

 class Program
    {
        static void Main(string[] args)
        {
            int[] num = new int[] { 1, 2, 3, 4, 5 };
            ArrayList arrayList = new ArrayList { 1, 2, 3, 4, 5 };
            Console.WriteLine(Sum(num));
            Console.WriteLine(Avg(num));

            Console.WriteLine(Sum(arrayList));
            Console.WriteLine(Avg(arrayList));

            Console.ReadKey();
        }
        static int Sum(IEnumerable num)
        {
            int sum = 0;
            foreach(var n in num)
            {
                sum += (int)n;
            }
            return sum;
        }
        static double Avg(IEnumerable num)
        {
            int sum = 0;
            double count = 0;
            foreach (var n in num)
            {
                sum += (int)n;
                count++;
            }
            return sum/ count;
        }
    }

结果：

15
3
15
3

　　

2.依赖反转

https://blog.csdn.net/jerry11112/article/details/79027834 这里写的面向对象编程很不错

面向对象编程就是先抽象出对象，然后用对象执行方法的方式解决问题。

面向对象就是对现实世界的抽象，在现实世界中人与人之间相互协作分工做事，但是在抽象世界中，这种分工合作可以理解成“依赖”，相应的就出现了耦合。

（1）比如说汽车依赖于引擎才能跑，没有引擎，车也就没什么用处了。用面向对象的方式抽象出汽车和引擎2个类，代码如下：

  class Program
    {
        static void Main(string[] args)
        {
            Engine engine = new Engine();
            Car car = new Car(engine);
            car.Run(3);
            Console.WriteLine(car.Speed);

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 引擎
    /// </summary>
    class Engine
    {
        /// <summary>
        /// 转速，这里的属性只能读，不能在其他类进行修改
        /// </summary>
        public int RPM { get; private set; }
        /// <summary>
        /// 引擎转动，
        /// </summary>
        /// <param name="gas">汽油，汽油越多，转速越快，</param>
        public void Work(int gas)
        {
            this.RPM = 1000 * gas;
        }

    }
    /// <summary>
    /// 车类
    /// </summary>
    class Car
    {
        private Engine _engine;
        /// <summary>
        /// 车必须要有一个引擎，否则没法动。
        /// </summary>
        /// <param name="engine"></param>
        public Car(Engine engine)
        {
            _engine = engine;
        }
        public int Speed { get; private set; }
        /// <summary>
        /// 汽车运行
        /// </summary>
        /// <param name="gas"></param>
        public void Run(int  gas)
        {
            _engine.Work(gas);
            this.Speed = _engine.RPM / 100;

        }
    }

从上面代码我们可以看出，car类是完全依赖于engine类的，被依赖的类一旦除了问题，依赖的一方也会出问题，如果代码一多，问题处理起来就会很麻烦。在实际工作中，如果一个程序员负责开发engine类，但是只有这个类问题改完，其他依赖于这个类的其他类才能继续使用。

 （2）接口

如上述情况，我们可以使用接口，来实现降低耦合度。接口就是一组契约，用来约束一组功能。接口的调用者是被约束的，只能调用接口中所包含的功能。还保证了这些接口中的功能一定是实现好了的。

接口的产生：自底向上（重构），自顶向下（设计）

在接到一个项目的时候，如果你是一个很厉害的并且理解这个项目的业务逻辑，在一开始的时候就想到了在什么地方用接口，此时就是自顶向下的方式产生接口。但是更多的时候是我们在写代码的过程中不断的重构代码，觉得哪些地方需要接口

例子：比如以前的旧手机，一定会有的功能是打电话，接电话，发短信，收短信。我们用接口来实现这些功能。我用的手机是一定会有这些功能的，而且这些功能都是好用的。请注意，这个接口对于手机厂商来说，这四个功能是必须要实现的。使用接口实现的好处在于你更换手机之后还是可以直接用，不存在换了手机之后这4个功能就有不能用的了。

代码如下：

namespace TestClass
{
    class Program
    {
        static void Main(string[] args)
        {
            var user = new PhoneUser(new HUANWEIPhone());
            user.UsePhone();
            

            Console.ReadKey();
        }
    }

    public interface IPhone
    {

        void Dail();
        void PickUp();
        void Send();
        void Receive();
    }
    /// <summary>
    /// 诺基亚手机
    /// </summary>
    public class NokiaPhone : IPhone
    {
        public void Dail()
        {
            Console.WriteLine("NokiaPhone  is Dailing");
        }

        public void PickUp()
        {
            Console.WriteLine("NokiaPhone  is PickUping");
        }

        public void Receive()
        {
            Console.WriteLine("NokiaPhone  isReceiveing");
        }

        public void Send()
        {
            Console.WriteLine("NokiaPhone  is Sending");
        }
    }
    public class HUANWEIPhone : IPhone
    {
        public void Dail()
        {
            Console.WriteLine("HUANWEIPhone  is Dailing");
        }

        public void PickUp()
        {
            Console.WriteLine("HUANWEIPhone  is PickUping");
        }

        public void Receive()
        {
            Console.WriteLine("HUANWEIPhone  isReceiveing");
        }

        public void Send()
        {
            Console.WriteLine("HUANWEIPhone  is Sending");
        }
    }
    /// <summary>
    /// 手机使用者：它的行为就是能够使用不同的手机
    /// </summary>
    public class PhoneUser
    {
        private IPhone _phone;
        public PhoneUser(IPhone phone)
        {
            _phone = phone;
        }
        /// <summary>
        /// 使用手机以及其能力
        /// </summary>
        public void UsePhone()
        {
            _phone.Dail();
            _phone.PickUp();
            _phone.Send();
            _phone.Receive();
        } 
    } 
}

 结果：

HUANWEIPhone  is Dailing
HUANWEIPhone  is PickUping
HUANWEIPhone  is Sending
HUANWEIPhone  isReceiveing

（3）所以的依赖倒置，其中的依赖其实就是耦合性，如果A类依赖B类，那么当B类消失或修改时，对A类会有很大的影响，可以说是A类的存在完全就是为B类服务，就是说A类依赖B类。

看上图：1处是汽车司机只能开汽车，卡车司机只能开卡车，不能还换着开。Driver依赖Car,Trucker依赖Truck。

 2：改完设计之后，创建了一个IVehicle接口，让Car和Truck都实现这个接口(此时这2个类和接口也是紧耦合)，Driver依赖IVehicle。此时Driver既可以开Car，也可以开Trunk。注意看图，此时的箭头和1时方向变反了，所以依赖反转中的反转就是这样来的。

 3:当有多种使用者，多个选择的时候，就可以实现多种配对，如图3处。此时再进一步，那就是设计模式了。

 使用此时的设计模式来更改上面代码的话，可以加一个年轻人使用者类，如下：

public class YoungUser : PhoneUser
    {
        public YoungUser(IPhone phone) :base(phone)
        {
          
        }
    }

在调用的时候如下:

            var userYong = new YoungUser(new HUANWEIPhone()); 
            userYong.UsePhone();

（4）单元测试

写一个例子，表示接口，解耦，依赖倒置原则是怎么被单元测试应用的。

电扇都是由电启动的，电力越大，速度越快。但是它也是有电流保护的功能，电流过大会断开或警告。现在的依赖关系是电扇依赖电源（没有电源，电扇无法运行）。

我们先写一个紧耦合：

namespace TestClass
{
    class Program
    {
        static void Main(string[] args)
        {
            var fan = new DeskFan(new PowerSupply());
            fan.Work();
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 电源供应类
    /// </summary>
    public class PowerSupply
    {
        public int GetPower()
        {
            return 100;
        }
    }
    /// <summary>
    /// 电扇
    /// </summary>
    public class DeskFan
    {
        private PowerSupply _powerSupply;
        public DeskFan(PowerSupply powerSupply)
        {
            _powerSupply = powerSupply;
        }
        /// <summary>
        /// 运行，还要验证电流力度
        /// </summary>
        /// <returns></returns>
        public string Work()
        {
            int power = _powerSupply.GetPower();
            //简单判断一下
            if(power<=0)
            {
                return "Wont't work";
            }
            else
            {
                return "Working";
            }

        }
    } 
}

看上面代码，如果我们更改了PowerSupply中的 GetPower方法的返回值，来测试电扇，而且不只是电扇在使用这个电源，也许还有别的电器在使用，更改之后万一引起别的电器产生问题，那就不对了。所以我们可以抽象出一个电源提供接口，写一个测试类实现电源提供接口，专门用来测试电源对电力大小造成的影响，这样也不会影响到其他电器的使用，如下：

namespace TestClass
{
    class Program
    {
        static void Main(string[] args)
        {
            var fan = new DeskFan(new TestPowerSupply());
            fan.Work();
            Console.ReadKey();
        }
    }
    public  interface IPowerSupply
    {
        int GetPower();
    }

    /// <summary>
    /// 电源供应类
    /// </summary>
    public class PowerSupply:IPowerSupply
    {
        public int GetPower()
        {
            return 100;
        }
    }
    /// <summary>
    /// 测试电流
    /// </summary>
    public class TestPowerSupply : IPowerSupply
    {
        public int GetPower()
        {
            return 100000;
        }
    }
    /// <summary>
    /// 电扇
    /// </summary>
    public class DeskFan
    {
        private IPowerSupply _powerSupply;
        public DeskFan(IPowerSupply powerSupply)
        {
            _powerSupply = powerSupply;
        }
        /// <summary>
        /// 运行，还要验证电流力度
        /// </summary>
        /// <returns></returns>
        public string Work()
        {
            int power = _powerSupply.GetPower();
            //简单判断一下
            if(power<=0)
            {
                return "Wont't work";
            }
            else
            {
                return "Working";
            }

        }
    } 
}

要测试的话，我们可以使用单元测试进行调试。新建一个单元测试

namespace TestClassTests
{
    public class UnitTest1
    {
        [Fact]
        public void PowerLowerThanZero_OK()
        {
            var mock = new Mock<IPowerSupply>();
            mock.Setup(s=>s.GetPower()).Returns(()=>0); 
            var fan = new DeskFan(new PowerSupplyThanZero(0));
           var test= fan.Work();
            Assert.Equal("",test);

            //第二种写法，引用Moq.dll。此时就不需要再实现接口了，直接填需要的值
            var mock = new Mock<IPowerSupply>();
            mock.Setup(s => s.GetPower()).Returns(() => 0);

            var fan = new DeskFan(mock.Object);
            var test = fan.Work();
            Assert.Equal("", test);


        }
    } 
    public class PowerSupplyThanZero : IPowerSupply
    {
        private int _power;
        public PowerSupplyThanZero(int power)
        {
            _power = power;
        }
        public int GetPower()
        {
            return _power;
        }
    }
}

 引用于：https://www.bilibili.com/video/BV13b411b7Ht?p=28