[设计模式]接口隔离原则

使用多个专门的接口比使用单一的总接口总要好

接口隔离原则是指使用多个专门的接口(抽象类也是接口), 而不使用单的总接口. 每一个接口应该承担一种相对独立的角色, 不多不少, 不干不该干的事, 该干的事都要干.

采用接口隔离原则对接口进行约束时,要注意以下几点:

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

// 接口隔离原则001
namespace 接口隔离原则001
{
    public interface Iinterface
    {
        void Method01();
        void Method02();
        void Method03();
        void Method04();
        void Method05();
    }

    class A
    {
        public void Depend1(Iinterface iinterface)
        {
            iinterface.Method01();
        }

        public void Depend2(Iinterface iinterface)
        {
            iinterface.Method02();
        }

        public void Depend3(Iinterface iinterface)
        {
            iinterface.Method03();
        }
    }

    class B : Iinterface
    {
        public void Method01()
        {
            Console.WriteLine("B实现接口Method01");
        }

        public void Method02()
        {
            Console.WriteLine("B实现接口Method02");
        }

        public void Method03()
        {
            Console.WriteLine("B实现接口Method03");
        }

        public void Method04()
        {
        }

        public void Method05()
        {
        }
    }

    public class C
    {
        public void Depend1(Iinterface iinterface)
        {
            iinterface.Method01();
        }

        public void Depend2(Iinterface iinterface)
        {
            iinterface.Method04();
        }

        public void Depend3(Iinterface iinterface)
        {
            iinterface.Method05();
        }
    }

    public class D : Iinterface
    {
        public void Method01()
        {
            Console.WriteLine("D实现接口Method01");
        }

        public void Method02()
        { }

        public void Method03()
        { }

        public void Method04()
        {
            Console.WriteLine("D实现接口Method04");
        }

        public void Method05()
        {
            Console.WriteLine("D实现接口Method05");
        }
    }

    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.Depend3(new D());
        }
    }
}

// 接口隔离原则002
namespace 接口隔离原则002
{
    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 i)
        {
            i.Method2();
        }

        public void Depend3(I2 i)
        {
            i.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 i)
        {
            i.Method1();
        }

        public void Depend2(I3 i)
        {
            i.Method4();
        }

        public void Depend3(I3 i)
        {
            i.Method5();
        }
    }

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

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

        public void Method5()
        {
            Console.WriteLine("D实现接口I3的Method5");
        }
    }

    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.Depend3(new D());
        }
    }
}