设计模式六大原则：接口隔离原则

目录： 

　　设计模式六大原则：单一职责原则

　　设计模式六大原则：接口隔离原则 

　　设计模式六大原则：依赖倒置原则

　　设计模式六大原则：里氏替换原则

　　设计模式六大原则：迪米特法则

　　设计模式六大原则：开闭原则

接口隔离原则(Interface Segregation Principle)：

　　1、客户端不应依赖它不需要的接口

　　2、类间的依赖关系应该建立在最小的接口上

　　其实通俗来理解就是，不要在一个接口里面放很多的方法，这样会显得这个类很臃肿。接口应该尽量细化，一个接口对应一个功能模块，同时接口里面的方法应该尽可能的少，使接口更加灵活轻便。或许有的人认为接口隔离原则和单一职责原则很像，但两个原则还是存在着明显的区别。单一职责原则是在业务逻辑上的划分，注重的是职责。接口隔离原则是基于接口设计考虑。例如一个接口的职责包含10个方法，这10个方法都放在同一接口中，并且提供给多个模块调用，但不同模块需要依赖的方法是不一样的，这时模块为了实现自己的功能就不得不实现一些对其没有意义的方法，这样的设计是不符合接口隔离原则的。接口隔离原则要求"尽量使用多个专门的接口"专门提供给不同的模块。

经典案例：

　　类A通过Interface1依赖类B，1，2，3；类B通过Interface1依赖D，1，4，5。

　　

internal class Program
{
    private static void Main(string[] args)
    {
        A a = new A();
        B b = new B();
        a.use1(b);
        a.use2(b);
        a.use3(b);
    }
}

internal interface interface1
{
    void operation1();

    void operation2();

    void operation3();

    void operation4();

    void operation5();
}

internal class B : interface1
{
    public void operation1()
        {
            Console.WriteLine($"B->{nameof(operation1)}");
        }

    public void operation2()
        {
            Console.WriteLine($"B->{nameof(operation2)}");
        }

    public void operation3()
        {
            Console.WriteLine($"B->{nameof(operation3)}");
        }

    public void operation4()
        {
            Console.WriteLine($"B->{nameof(operation4)}");
        }

    public void operation5()
        {
            Console.WriteLine($"B->{nameof(operation5)}");
        }
}

internal class D : interface1
{
    public void operation1()
        {
            Console.WriteLine($"D->{nameof(operation1)}");
        }

    public void operation2()
        {
            Console.WriteLine($"D->{nameof(operation2)}");
        }

    public void operation3()
        {
            Console.WriteLine($"D->{nameof(operation3)}");
        }

    public void operation4()
        {
            Console.WriteLine($"D->{nameof(operation4)}");
        }

    public void operation5()
        {
            Console.WriteLine($"D->{nameof(operation5)}");
        }
}

internal class A
{
    public void use1(interface1 interface1)
        {
            interface1.operation1();
        }

    public void use2(interface1 interface1)
        {
            interface1.operation2();
        }

    public void use3(interface1 interface1)
        {
            interface1.operation3();
        }
}

internal class C
{
    public void use1(interface1 interface1)
        {
            interface1.operation1();
        }

    public void use4(interface1 interface1)
        {
            interface1.operation4();
        }

    public void use5(interface1 interface1)
        {
            interface1.operation5();
        }
}

　　显然，上述设计不符合接口隔离原则。

　　

internal class Program
{
    private static void Main(string[] args)
    {
        A a = new A();
        B b = new B();
        a.use1(b);
        a.use2(b);
        a.use3(b);
    }
}

internal interface interface1
{
    void operation1();
}

internal interface interface2
{
    void operation2();

    void operation3();
}

internal interface interface3
{
    void operation4();

    void operation5();
}

internal class B : interface1, interface2
{
    public void operation1()
        {
            Console.WriteLine($"B->{nameof(operation1)}");
        }

    public void operation2()
        {
            Console.WriteLine($"B->{nameof(operation2)}");
        }

    public void operation3()
        {
            Console.WriteLine($"B->{nameof(operation3)}");
        }
}

internal class D : interface1, interface3
{
    public void operation1()
        {
            Console.WriteLine($"D->{nameof(operation1)}");
        }

    public void operation4()
        {
            Console.WriteLine($"D->{nameof(operation4)}");
        }

    public void operation5()
        {
            Console.WriteLine($"D->{nameof(operation5)}");
        }
}

internal class A
{
    public void use1(interface1 interface1)
    {
        interface1.operation1();
    }

    public void use2(interface2 interface2)
    {
        interface2.operation2();
    }

    public void use3(interface2 interface2)
    {
        interface2.operation3();
    }
}

internal class C
{
    public void use1(interface1 interface1)
    {
        interface1.operation1();
    }

    public void use4(interface3 interface3)
    {
        interface3.operation4();
    }

    public void use5(interface3 interface3)
    {
        interface3.operation5();
    }
}