Unity设计模式---接口隔离原则

接口隔离原则

接口隔离原则：使用多个专门的接口比使用单一的接口好；
从客户类讲，一个类对另一个类的依赖性应建立在最小接口上;
过于臃肿的接口是对接口的污染；
不应该强迫客户依赖于他们不使用的方法。
注意：在该定义中的接口值得是所定义的方法。

接口隔离原则分析

接口隔离原则是使用多个专门的接口（抽象类也是接口），而不使用单一的总接口。每一个接口都应该
承担一种相对独立的角色，不多不少，不干不该干的事，该干的事都要干。
（1）一个接口就只代表一个角色，每个角色都有它特定的一个接口，所以又叫角色隔离原则
（2）接口仅仅提供客户端需要的行为，即所需的方法，客户端不需要的行为则隐藏起来，应当为客户端
提供尽可能小的单独的接口，而不要提供大的总接口。

接口隔离原则注意事项

采用接口隔离原则时，需要注意:
接口尽量小，但是要有限度。对接口细化可以提高程序的灵活性，但是接口过小，会造成接口过多，使
设计复杂化。所以一定要适度。
为依赖接口的类定制服务，只暴露给调用的类所需要的方法，不需要的方法隐藏起来。只有专注地为一个
模块提供定制服务，才能建立最小的依赖关系。
提高内聚，减少对外交互，使接口用最少的方法完成最多的事情。运用接口隔离原则，一定要适度。接口
设计的过大或过小都不好。设计接口的时候，需要多花时间去思考和筹划，才能准确地实践这一原则。

接口隔离原则实例

namespace 接口隔离原则
{
    public interface IMethod
    {
        void Method1();
        void Method2();

        void Method3();

        void Method4();

        void Method5();
    };

    public class A
    {
        //依赖方法
        public void Depend1(IMethod method)
        { 
            method.Method1();
        }

        public void Depend2(IMethod method) 
        { 
            method.Method2();
        }

        public void Depend3(IMethod method)
        {
            method.Method3();
        }
    }

    /// <summary>
    /// 当一个接口包含的方法太多时，有的方法用不到，这就是所谓的胖接口
    /// </summary>
    public class B : IMethod
    {
        public void Method1()
        {
            Console.WriteLine("类B实现了接口IMehtod的方法1");
        }

        public void Method2()
        {
            Console.WriteLine("类B实现了接口IMehtod的方法2");
        }

        public void Method3()
        {
            Console.WriteLine("类B实现了接口IMehtod的方法3");
        }

        public void Method4()
        {
            Console.WriteLine("类B实现了接口IMehtod的方法4");
        }

        public void Method5()
        {
            Console.WriteLine("类B实现了接口IMehtod的方法5");
        }
    }

    /// <summary>
    /// 接口需要灵活扩展
    /// </summary>
    public class C 
    {
        public void Depend1(IMethod method)
        {
            method.Method1();

        }

        public void Depend2(IMethod method)
        { 
            method.Method4();
        }

        public void Depend5(IMethod method)
        { 
            method.Method5();
        }
    }

    public class D : IMethod
    {
        public void Method1()
        {
            Console.WriteLine("类D实现了接口IMehtod的方法1");
        }

        //对于不需要实现的接口，{}中可为空
        public void Method2()
        {}

        public void Method3()
        { }

        public void Method4()
        {
            Console.WriteLine("类D实现了接口IMehtod的方法4");
        }

        public void Method5()
        {
            Console.WriteLine("类D实现了接口IMehtod的方法5");
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            A a=new A();
            a.Depend1(new B());
            a.Depend2(new B());
            a.Depend3(new B());

            C c=new C();
            c.Depend1(new D());
            c.Depend2(new D());
            c.Depend5(new D());
            Console.ReadLine();
        }
    }
}

接口隔离原则实例2

namespace 接口隔离原则2
{
    public interface I1
    {
        void Method1();
    }

    public interface I2 
    {
        void Method2();
        void Method3();
    }

    public interface I3
    {

        void Method4();
        void Method5();
    }

    class A 
    {
        public void Depend1(I1 i1)
        { 
            i1.Method1();
        }
        public void Depend2(I2 i2) 
        { 
            i2.Method2();
        }
        public void Depend(I2 i2)
        {
            i2.Method3();
        }

    }
    class B : I1, I2
    {
        public void Method1()
        {
            Console.WriteLine("B实现I1的接口method1");
        }

        public void Method2()
        {
            Console.WriteLine("B实现I2的接口method2");
        }

        public void Method3()
        {
            Console.WriteLine("B实现I2的接口method3");
        }
    }

    class C
    {
        public void Depend1(I1 i1)
        {
            i1.Method1();
        }

        public void Depend2(I2 i2)
        { 
            i2.Method2();
        }

        public void Depend3(I2 i2)
        { 
            i2.Method3();
        }
    }

    class D : I1, I3
    {
        public void Method1()
        {
            Console.WriteLine("D实现I1的接口method1");
        }

        public void Method4()
        {
            Console.WriteLine("D实现I1的接口method4");
        }

        public void Method5()
        {
            Console.WriteLine("D实现I1的接口method5");
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            a.Depend1(new B());
            a.Depend2(new B());
           

            C c = new C();
            c.Depend1(new D());
            Console.ReadLine();

        }
    }
}

接口隔离原则总结:

当客户类被强迫依赖那些他们不需要的接口时，则这些客户类不得不受限于这些接口。这无意间导致了所有客户类之间的耦合。换句话说，如果一个客户类依赖了一个类，这个类包含客户类不需要的接口，但这些接口是其他客户类所需要的，那么当其它客户类要求修改这个类时，这个修改也将影响这个客户类。所以我们需要尽可能地避免这种耦合。

单一原则和接口隔离原则的区别

首先，单一职责原则注重职责；接口隔离原则注重对接口依赖的隔离；

其次,单一职责原则主要约束类，其次才是接口和方法，针对程序的实现和细节；而接口隔离原则主要约束接口，主要针对抽象，针对的是程序整体框架的构建。