Programmation C sharp/Interfaces

Un livre de Wikibooks.

   

   

Programmation C#

Sommaire

Introduction Compilation Un premier programme

Le langage

Les commentaires Les espaces de noms Les variables et les constantes Les types de base et les déclarations Les tableaux Les objets Les classes Les fonctions Propriétés et indexeurs Les opérateurs Les structures de contrôle Héritage de classes Classe abstraite Les exceptions Structures et énumérations Interfaces

Programmation avancée

Type partiel Surcharge des opérateurs Directives du préprocesseur Documentation XML des classes Attributs Delegates et events Types génériques Appel de plateforme Code non vérifié

API .Net

Interfaces graphiques Graphique vectoriel Fonctions asynchrones Threads et synchronisation Processus Entrées-sorties La sérialisation Les fichiers Programmation réseau Exécution distante

Ressources

Bibliographie et liens Index des mots-clés du langage Livre d'or

Modifier ce modèle

Une interface ne fait que décrire une liste de méthodes, sans implémentation. Le code de ces méthodes est fourni par les classes qui implémentent l'interface.

[modifier] Déclarer une interface

Le mot clé interface sert à déclarer une interface. Il est suivi par le nom de l'interface, qui par convention commence généralement par la lettre I (i majuscule comme interface).

Exemple :

public interface IAffichable
{
    /*
        Liste des méthodes que doivent posséder toutes les classes
        implémentant l'interface IAffichable :
    */
    public void Afficher();
    public void Afficher(string message);
}

Par convention, le nom d'une interface ne comportant qu'une seule méthode est celui de la méthode suivi du suffixe "able". Par exemple, si la seule méthode s'appelle Draw, l'interface est nommée IDrawable.

[modifier] Utiliser une interface

L'interface créée est un nouveau type dont les méthodes sont appelables sans connaître la classe qui les implémente.

Exemple :

public void Montrer(IAffichable affichable,string message)
{
    affichable.Afficher(message);
}

[modifier] Implémenter une interface

Une interface est implémentée par une classe la déclarant dans sa liste d'implémentation. Cette classe doit alors fournir le code de toutes les méthodes de l'interface, à moins de déclarer ces méthodes comme abstraites. Dans ce dernier cas, l'implémentation devra être effectuée par une sous-classe.

Exemple :

using System;
 
public class Personne : IAffichable
{
    private string nom, prenom;
 
    public void Afficher()
    {
        Console.WriteLine(nom+" "+prenom);
    }
 
    public void Afficher(string message)
    {
        Console.WriteLine(nom+" "+prenom+" : "+message);
    }
}

[modifier] Méthodes, propriétés, indexeurs, events

Une interface peut en fait déclarer des méthodes, des propriétés, des indexeurs et des events.

Exemple :

public interface IExemple
{
    // Méthode à implémenter :
    public void UneMethodeAImplementer();
 
    // Propriétés à implémenter :
    public string UneProprieteAImplementer { get; set; }
    public string UneProprieteLectureSeuleAImplementer { get; }
 
    // Tableau de string à implémenter (indexeur) :
    public string this [ int index ] { get; set; }
 
    // Evènement à implémenter :
    public event PageRecueDelegate PageRecue { add; remove; }
}

[modifier] Héritage

Une interface peut hériter d'une autre interface. Elle possède donc les mêmes déclarations que l'interface de base en plus de ces propres déclarations. En outre, elle peut être utilisée là ou une implémentation de l'interface de base est requise.

Exemple :

public interface IDrawable
{
    public void Draw();
}
 
public interface IPrintable : IDrawable
{
    public void Print();
}
 
public class Cercle : IPrintable
{
    public void Draw()
    {
        ...
    }
 
    public void Print()
    {
        ...
    }
}
 
...
public void Methode()
{
    IDrawable drawable = new Cercle();
    // ^ conversion implicite de IPrintable vers IDrawable
    drawable.Draw();
}