Interfaces (introduction) et implémentation de plusieurs interfaces
Définissez les interfaces comme des contrats, implémentez plusieurs interfaces dans une même classe, utilisez le polymorphisme fondé sur les interfaces et découvrez les bases de leur implémentation explicite.
Interfaces (introduction) et implémentation de plusieurs interfaces est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.
Vue d’ensemble des interfaces
Objectif : programmer avec des interfaces pour obtenir un code flexible.
- Les interfaces déclarent quoi, pas comment
- Implémentez plusieurs interfaces
- Passez des interfaces aux fonctions
- L’implémentation explicite résout les conflits de noms
Implémenter plusieurs interfaces
Les interfaces définissent un contrat. Une classe peut implémenter plusieurs interfaces pour exprimer différents rôles.
using System;
public interface IPlayable
{
void Play();
}
public interface IHasDuration
{
int DurationSeconds { get; }
}
public class Song : IPlayable, IHasDuration
{
private readonly string _title;
private readonly int _seconds;
public Song(string title, int seconds)
{
_title = title;
_seconds = seconds;
}
public int DurationSeconds { get { return _seconds; } }
public void Play()
{
Console.WriteLine("Playing " + _title + " (" + _seconds + "s)");
}
}
public class Program
{
public static void Main(string[] args)
{
Song s = new Song("Hello", 5);
s.Play();
Console.WriteLine("Duration = " + s.DurationSeconds);
}
}
Polymorphisme des interfaces
Acceptez un type interface dans les méthodes. Les appelants peuvent transmettre n’importe quelle implémentation.
using System;
public interface IPrintable
{
void Print();
}
public class Report : IPrintable
{
private readonly string _text;
public Report(string text) { _text = text; }
public void Print() { Console.WriteLine("Report: " + _text); }
}
public class Label : IPrintable
{
private readonly string _text;
public Label(string text) { _text = text; }
public void Print() { Console.WriteLine("Label: " + _text); }
}
public class Program
{
// Works with any IPrintable (polymorphism)
static void PrintAll(IPrintable item)
{
item.Print();
}
public static void Main(string[] args)
{
PrintAll(new Report("Sales Q1"));
PrintAll(new Label("Fragile"));
}
}
Implémentation explicite
L’implémentation explicite distingue les membres portant le même nom et les masque de la surface de la classe.
using System;
public interface ILogger { void Write(string msg); }
public interface IFileWriter { void Write(string msg); }
public class DualWriter : ILogger, IFileWriter
{
// Explicit implementations: only visible via the interface reference
void ILogger.Write(string msg) { Console.WriteLine("[LOG] " + msg); }
void IFileWriter.Write(string msg) { Console.WriteLine("[FILE] " + msg); }
public void Demo()
{
Console.WriteLine("DualWriter ready");
}
}
public class Program
{
public static void Main(string[] args)
{
DualWriter dw = new DualWriter();
dw.Demo();
ILogger log = dw;
IFileWriter file = dw;
log.Write("started");
file.Write("saved");
}
}
Collections d’interfaces
Stockez différentes implémentations dans une liste du type de l’interface et parcourez-les uniformément.
using System;
using System.Collections.Generic;
public interface ITask
{
void Run();
}
public class EmailTask : ITask
{
public void Run() { Console.WriteLine("Send email"); }
}
public class BackupTask : ITask
{
public void Run() { Console.WriteLine("Run backup"); }
}
public class Program
{
public static void Main(string[] args)
{
List<ITask> tasks = new List<ITask>();
tasks.Add(new EmailTask());
tasks.Add(new BackupTask());
foreach (ITask t in tasks)
{
t.Run(); // calls the right implementation
}
}
}
Conseils sur les interfaces
Conseils :
- Préférez les petites interfaces décrivant un seul rôle.
- Utilisez les interfaces pour les tests (remplacez les implémentations).
- En C# 6, les interfaces ne possèdent ni fields ni corps de méthodes.
- Implémentez plusieurs interfaces pour composer les comportements.
Concept des interfaces
Récapitulatif
Récapitulatif : les interfaces sont des contrats et prennent en charge plusieurs implémentations par classe. Passez des interfaces aux fonctions, gardez-les petites et utilisez l’implémentation explicite pour résoudre les conflits.
Questions Fréquemment Posées
La leçon « Interfaces (introduction) et implémentation de plusieurs interfaces » est-elle gratuite ?
Oui — le texte complet de « Interfaces (introduction) et implémentation de plusieurs interfaces » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Interfaces (introduction) et implémentation de plusieurs interfaces » ?
Définissez les interfaces comme des contrats, implémentez plusieurs interfaces dans une même classe, utilisez le polymorphisme fondé sur les interfaces et découvrez les bases de leur implémentation e… Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C# Academy ?
Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.
Combien de temps prend la leçon « Interfaces (introduction) et implémentation de plusieurs interfaces » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?
Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- virtual/override/sealed et classes abstraites
- Interfaces (introduction) et implémentation de plusieurs interfaces
- Polymorphisme et répartition dynamique