ASP.NET: незнакомы с интерфейсами

Question

Я создаю приложение достойного размера в ASP.NET/VB.NET с различными объектами ... Я никогда раньше не использовал интерфейсы, и один из программистов возразил, когда я упомянул об этом ему. Может ли кто-нибудь дать мне краткий обзор того, как они используются, для чего они используются и почему я буду их использовать? Может быть, мне не нужно использовать их для этого проекта, но если они помогут, я, безусловно, с удовольствием попробую.

Большое спасибо!

Answer 1

Как только вы «получаете» интерфейсы, ООП действительно становится на свои места. Проще говоря, интерфейс определяет набор открытых сигнатур методов, вы создаете класс, который реализует эти методы. Это позволяет обобщать функции для любого класса, который реализует определенный интерфейс (т.е. классы, которые имеют одинаковые методы), даже если эти классы не обязательно происходят друг от друга.

Module Module1

    Interface ILifeform
        ReadOnly Property Name() As String
        Sub Speak()
        Sub Eat()
    End Interface

    Class Dog
        Implements ILifeform

        Public ReadOnly Property Name() As String Implements ILifeform.Name
            Get
                Return "Doggy!"
            End Get
        End Property

        Public Sub Speak() Implements ILifeform.Speak
            Console.WriteLine("Woof!")
        End Sub

        Public Sub Eat() Implements ILifeform.Eat
            Console.WriteLine("Yum, doggy biscuits!")
        End Sub
    End Class

    Class Ninja
        Implements ILifeform

        Public ReadOnly Property Name() As String Implements ILifeform.Name
            Get
                Return "Ninja!!"
            End Get
        End Property

        Public Sub Speak() Implements ILifeform.Speak
            Console.WriteLine("Ninjas are silent, deadly killers")
        End Sub

        Public Sub Eat() Implements ILifeform.Eat
            Console.WriteLine("Ninjas don't eat, they wail on guitars and kick ass")
        End Sub
    End Class

    Class Monkey
        Implements ILifeform


        Public ReadOnly Property Name() As String Implements ILifeform.Name
            Get
                Return "Monkey!!!"
            End Get
        End Property

        Public Sub Speak() Implements ILifeform.Speak
            Console.WriteLine("Ook ook")
        End Sub

        Public Sub Eat() Implements ILifeform.Eat
            Console.WriteLine("Bananas!")
        End Sub
    End Class


    Sub Main()
        Dim lifeforms As ILifeform() = New ILifeform() {New Dog(), New Ninja(), New Monkey()}
        For Each x As ILifeform In lifeforms
            HandleLifeform(x)
        Next

        Console.ReadKey(True)
    End Sub

    Sub HandleLifeform(ByVal x As ILifeform)
        Console.WriteLine("Handling lifeform '{0}'", x.Name)
        x.Speak()
        x.Eat()
        Console.WriteLine()
    End Sub
End Module

Ни один из вышеперечисленных классов не происходит друг от друга, но мой метод HandleLifeform обобщен для работы со всеми из них - или действительно с любым классом, который реализует интерфейс ILifeform.

Answer 2

Поскольку основы уже были рассмотрены, давайте перейдем к практическим примерам.

Скажем, у меня будет словарь, в котором хранятся ключи String и объекты Person, и я передам этот словарь (фактически ссылку на него) некоторым имеющимся у меня методам.

Теперь мой метод приема будет выглядеть примерно так:

Imports System.Collections.Generic
Public Sub DoSomething(ByVal myDict As Dictionary(Of String, Person))
    ' Do something with myDict here
End Sub

право

Но что, если кто-то изобрел какой-нибудь новый высокопроизводительный словарный класс? Я должен повернуться и изменить каждую ссылку на словарь на FastDictionary!

Однако, если бы я сначала кодировал интерфейс, у меня не было бы этой проблемы:

Imports System.Collections.Generic
Public Sub DoSomething(ByVal myDict As IDictionary(Of String, Person))
    ' Do something with myDict here
End Sub

Теперь требуется любой словарь!

Answer 3

Интерфейсы в основном позволяют определять контракт типа без указания его реализации.

Идея состоит в том, что если вы знаете, что данный тип реализует определенный интерфейс, это гарантирует, что определенные методы и свойства являются членами этого типа.

Так что любой тип, который реализует следующий интерфейс:

Interface ISpinnable
    Sub Spin()
End Interface

Должен быть реализован метод Spin. Но вызывающий объект этого типа, который реализует ISpinnable, не заботится о , как это реализовано, он просто заботится о том, чтобы метод был там. Вот тип, который реализует ISpinnable:

Class Top Implements ISpinnable
    Sub Spin()
        ' do spinning stuff
    End Sub
End Class

Преимущество этого заключается в том, что вы можете создавать аргументы метода типа ISpinner и позволять вызывающей стороне этих методов передавать вам любой тип, пока он реализует интерфейс. Ваш метод больше не связан с конкретным типом, который использует вызывающая сторона.

Answer 4

Классическим примером является Уровень данных, где вы используете его для поддержки нескольких форматов базы данных. На самом деле это было очень полезно до того, как ORMappers вошли в общую картину программирования.

Ваш интерфейс просто сообщает, какой тип метода и свойства имеет ваш объект, затем сам объект должен реализовать эти методы.

IMyDatabase myDb;

switch case myDbFormat {
     case "mysql":
        myDb = new MyDbMySql();
        break;
     case "mssql" :
        myDb = new MyDbMsSql();
        break;    
}

myDb.SaveToDatabase(some data)

Конечно, классы myDb должны реализовывать интерфейс ImyDatabase. Я полагаю, вы видите, насколько это полезно:).

Answer 5

Одной из вещей, которая может быть полезна интерфейсам, является просмотр массива объектов разных типов, но имеющих один и тот же интерфейс. Не могу сказать о VB, но в C # вы можете использовать удобный оператор «is», чтобы определить, реализует ли тип объекта данный интерфейс и безопасно ли осуществлять доступ к методам этого интерфейса путем приведения. Извините за C #, но я постараюсь поместить некоторые комментарии в =))

//we declare 3 different interfaces each requiring to implement one method
                    interface IProgrammer
                    {
                        void WriteCode();
                    }

                    interface ITester
                    {
                         void FindBugs();
                    }

                    interface IWorker
                    {
                         void StartShift();
                    }

        // each programmer will be able to start his shift and write code
                    class Programmer : IWorker, IProgrammer
                    {

                        public void StartShift()
                        {
                          // ...
                        }

                        public void WriteCode()
                        {
                          // ...
                        }

                    }

        // each tester will be able to start his shift and find bugs

                    class Tester : IWorker, ITester
                    {
                        public void StartShift()
                        {
                            // ...
                        }

                        public void FindBugs()
                        {
                            // ...
                        }
                    }

            //then in code you can rely on objects implementing the interface to 
            // be able to do tasks interface requires to do
                    static void Main()
                    {
                        IWorker[] workers = new IWorker[3];
                        workers[0] = new Programmer();
                        workers[1] = new Tester();
                        workers[2] = new Tester();

       // now we can browse through array of different workers because they all share
       // the IWorker interface
                    foreach(IWorker worker in workers)
                    {
                        // All IWorkers can StartShift so we access its methods without casts
                        worker.StartShift();
                        if(worker is IProgrammer)
                        {
                            // Since that worker also implements IProgrammer
                            // we cast worker as IProgrammer and access IProgrammer method(s)
                            (worker as IProgrammer).WriteCode();
                        }
                        if(worker is ITester)
                        {
                            // Same,
                            // we cast worker as ITester and access ITester method(s)
                            // handy! =)
                             (worker as ITester).FindBugs();
                        }
                    }

Answer 6

Интерфейс - это контракт без реализации. Он позволяет вам определить, как будет выглядеть тип, не указывая, какова реализация этого типа.

Это позволяет вам иметь различные реализации интерфейса, которые будут соответствовать вашим конкретным потребностям.

Хороший пример - интерфейс IComparer(Of T). Вы можете иметь одну реализацию, которая будет сравнивать два элемента на основе большего, а затем другую, которая будет возвращать значение, на основе которого меньше.

Затем вы можете передать один или другой метод статической сортировки в классе Array для сортировки элементов в порядке возрастания или убывания соответственно.