ASP.NET : Pas familier avec les interfaces

Question

Je suis en train de construire une application de taille raisonnable en ASP.NET/VB.NET avec différents objets... Je n'ai jamais utilisé d'interfaces auparavant, et un collègue programmeur s'est montré réticent lorsque je lui en ai parlé. Quelqu'un peut-il me donner un aperçu rapide de la façon dont elles sont utilisées, à quoi elles servent et pourquoi je les utiliserais ? Peut-être que je n'ai pas besoin de les utiliser pour ce projet, mais si elles peuvent m'aider, j'aimerais bien essayer.

Merci beaucoup !

Answer 1

Une fois que l'on a "compris" les interfaces, la POO se met vraiment en place. Pour simplifier, une interface définit un ensemble de signatures de méthodes publiques, vous créez une classe qui implémente ces méthodes. Cela permet de généraliser les fonctions pour toute classe qui implémente une interface particulière (c'est-à-dire les classes qui ont les mêmes méthodes), même si ces classes ne descendent pas nécessairement les unes des autres.

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

Aucune des classes ci-dessus ne descend d'une autre, mais ma méthode HandleLifeform est généralisée pour opérer sur toutes ces classes - ou en fait sur toute classe qui implémente l'interface ILifeform.

Answer 2

Les principes de base ayant déjà été abordés, passons aux exemples pratiques.

Disons que je vais avoir un dictionnaire qui stocke des clés de type chaîne et des objets de type personne et que je vais passer ce dictionnaire (en fait, la référence à ce dictionnaire) à certaines méthodes que j'ai.

Maintenant, ma méthode de réception ressemblerait à quelque chose comme

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

n'est-ce pas ?

Mais que se passe-t-il si quelqu'un invente une nouvelle classe de dictionnaire très performante ? Je dois alors changer toutes les références au dictionnaire en FastDictionary !

Cependant, si j'avais codé en fonction de l'interface dès le départ, je n'aurais pas eu ce problème :

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

Maintenant, il prend n'importe quel dictionnaire !

Answer 3

Les interfaces permettent essentiellement de définir le contrat d'un type sans spécifier son implémentation.

L'idée est que si vous savez qu'un type donné met en œuvre une certaine interface, cela garantit que certaines méthodes et propriétés sont membres de ce type.

Donc tout type qui implémente l'interface suivante :

Interface ISpinnable
    Sub Spin()
End Interface

Il faudrait mettre en œuvre le Spin méthode. Mais l'appelant de ce type qui implémente la méthode ISpinnable ne se préoccupe pas de comment qu'elle est implémentée, il se préoccupe simplement de l'existence de la méthode. Voici un type qui implémente ISpinnable :

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

L'avantage est que vous pouvez créer des arguments de méthode de type ISpinner et permettent à l'appelant de ces méthodes de vous passer n'importe quel type tant qu'il implémente l'interface. Votre méthode n'est plus étroitement liée au type concret utilisé par l'appelant.

Answer 4

Une interface est un contrat sans implémentation. Elle permet de définir l'aspect d'un type sans indiquer l'implémentation de ce type.

Cela vous permet d'avoir plusieurs implémentations d'une interface, qui répondront à vos besoins particuliers.

Un bon exemple est le IComparer(Of T) l'interface. Vous pouvez avoir une implémentation qui comparera deux éléments en fonction de celui qui est le plus grand, et une autre qui renverra une valeur en fonction de celle qui est la plus petite.

Ensuite, vous pouvez passer l'un ou l'autre à la méthode statique Sort de la classe Array pour trier vos éléments dans l'ordre croissant ou décroissant, respectivement.

Answer 5

Les interfaces peuvent être utiles, entre autres, pour parcourir le tableau d'objets de types différents mais qui partagent la même interface. Je ne peux pas dire ce qu'il en est pour VB, mais en C#, vous pouvez utiliser l'opérateur "is" pour déterminer si le type de l'objet implémente l'interface donnée et s'il est possible d'accéder aux méthodes de cette interface en toute sécurité par moulage. Désolé pour le C#, mais je vais essayer de mettre quelques commentaires =))

//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();
                        }
                    }