C# Interface

Une interface définit un contrat syntaxique que toutes les classes doivent respecter lorsqu'elles héritent de l'interface. Une interface définit un contrat syntaxique."Qu'est-ce que c'est"En partie, les classes dérivées définissent le contrat syntaxique"Comment faire"partie.

Une interface définit les propriétés, les méthodes et les événements, qui sont tous des membres de l'interface. L'interface ne contient que des déclarations de membres. La définition des membres incombe aux classes dérivées. L'interface fournit une structure standard que les classes dérivées doivent suivre.

Une interface uniformise la forme des classes ou structures qui l'implémentent.

Les classes abstraites sont quelque peu similaires aux interfaces, mais elles ne sont généralement utilisées que lorsque quelques méthodes sont déclarées par la classe de base et implémentées par les classes dérivées.

L'interface elle-même n'implémente aucune fonctionnalité ; elle établit simplement un contrat avec l'objet qui déclare implémenter l'interface, en spécifiant quels comportements doivent être implémentés.

Les classes abstraites ne peuvent pas être instanciées directement, mais elles permettent de dériver des classes concrètes avec une fonctionnalité réelle.

Définir l'interface : MyInterface.cs

Utilisation des interfacesinterfaceDéclaration de mot-clé, qui est similaire à la déclaration de classe. Les déclarations d'interface sont publiques par défaut. Voici un exemple de déclaration d'interface :

interface IMyInterface
{
    void MethodToImplement();
}

Le code ci-dessus définit l'interface IMyInterface. Habituellement, les noms d'interface commencent parIla lettre I. Cette interface n'a qu'une seule méthode, MethodToImplement(), sans paramètres ni valeur de retour. Bien sûr, nous pouvons définir des paramètres et des valeurs de retour selon les besoins.

Il est à noter que cette méthode n'a pas d'implémentation concrète.

Ensuite, implémentons l'interface ci-dessus : InterfaceImplementer.cs

Exemple

using System;

interface IMyInterface
{
        // Membres de l'interface
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }
}

La classe InterfaceImplementer implémente l'interface IMyInterface. L'implémentation d'une interface est similaire en syntaxe à l'héritage de classe :

class InterfaceImplementer : IMyInterface

Après avoir hérité de l'interface, nous devons implémenter la méthode MethodToImplement() de l'interface. Le nom de la méthode doit correspondre au nom de la méthode défini dans l'interface.

Héritage d'interface : InterfaceInheritance.cs

L'exemple suivant définit deux interfaces, IMyInterface et IParentInterface.

Si une interface hérite d'autres interfaces, alors la classe ou la structure qui l'implémente doit implémenter tous les membres des interfaces.

Dans l'exemple suivant, IMyInterface hérite de l'interface IParentInterface ; par conséquent, la classe d'implémentation de l'interface doit implémenter les méthodes MethodToImplement() et ParentInterfaceMethod() :

Exemple

using System;

interface IParentInterface
{
    void ParentInterfaceMethod();
}

interface IMyInterface : IParentInterface
{
    void MethodToImplement();
}

class InterfaceImplementer : IMyInterface
{
    static void Main()
    {
        InterfaceImplementer iImp = new InterfaceImplementer();
        iImp.MethodToImplement();
        iImp.ParentInterfaceMethod();
    }

    public void MethodToImplement()
    {
        Console.WriteLine("MethodToImplement() called.");
    }

    public void ParentInterfaceMethod()
    {
        Console.WriteLine("ParentInterfaceMethod() appelée.");
    }
}

Le résultat de sortie de l'exemple est :

MethodToImplement() called.
ParentInterfaceMethod() called.
autres extensions