interfaces sont le principal moyen de découpler les utilisations d'une classe de son implémentation. Ce découplage apporte de la souplesse pour la maintenance de l'implémentation et aide à prendre en charge un comportement générique sûr du point de vue du typage.
La syntaxe d'une interface est semblable à celle d'une classe ou d'un struct, à la différence près que les méthodes et les propriétés n'apparaissent que sous forme de signature et qu'aucun corps n'est fourni.
public interface ILanguage
{
string Speak();
}
public interface IItalianLanguage : ILanguage
{
string Speak();
string SpeakItalian();
}
public interface IScriptConverter
{
string Version { get; set; }
string ConvertCyrillicToLatin(string cyrillic);
}
La classe ou le struct qui implémente l'interface doit implémenter toutes les opérations définies par l'interface.
Les interfaces font généralement une ou plusieurs des choses suivantes :
IComparable<T>) ;public class ItalianTraveller : IItalianLanguage
{
public string Speak()
{
return "Ciao mondo";
}
public string SpeakItalian()
{
return Speak();
}
}
public class ItalianTravellerV2 : IItalianLanguage
{
public string Speak()
{
return "migliorata - Ciao mondo";
}
public string SpeakItalian()
{
return Speak();
}
}
public class FrenchTraveller : ILanguage
{
public string Speak()
{
return "Ça va?";
}
}
public class RussianTraveller : ILanguage, IScriptConverter
{
public string Version { get; set; } = "1.0";
public string Speak()
{
return "Привет мир";
}
public string ConvertCyrillicToLatin(string cyrillic)
{
throw new NotImplementedException();
}
}
public class DocumentTranslator : IScriptConverter
{
public string Version { get; set; } = "1.0";
public string Translate(string russian)
{
throw new NotImplementedException();
}
public string ConvertCyrillicToLatin(string cyrillic)
{
throw new NotImplementedException();
}
}
Le code qui utilise les interfaces et les classes ci-dessus peut :
Les interfaces sont largement utilisées pour faciliter les tests, car elles permettent un mocking aisé.
Consulte cet article pour savoir en détail quels types de membres une interface peut contenir.
Les interfaces peuvent hériter d'autres interfaces.
Par défaut, les membres d'une interface sont publics.
Les interfaces peuvent contenir des types imbriqués, comme des littéraux const, des enums, des delegates, des classes et des structs. Ici, les interfaces jouent le rôle d'espaces de noms, de la même manière que les classes et les structs, et leur comportement comme leur syntaxe sont identiques.
Par conception, C# ne prend pas en charge l'héritage multiple, mais il facilite une forme d'héritage multiple au moyen des interfaces.
De plus, le mécanisme des interfaces repose sur le concept selon lequel le polymorphisme peut être mis en œuvre au moyen d'interfaces.
Il arrive que deux interfaces différentes partagent les mêmes noms de méthodes et les mêmes signatures. Pour fournir une implémentation distincte de ces méthodes, C# propose l'implémentation explicite des interfaces. Note que pour utiliser une implémentation particulière d'une interface, tu dois convertir en cette interface l'expression qui référence l'objet. Une affectation, un transtypage ou un passage en paramètre permet d'y parvenir.
public interface IFoo
{
void X();
}
public interface IBar
{
void X();
}
public class Census : IFoo, IBar
{
void IFoo.X()
{
Console.Write("This is from Foo");
}
void IBar.X()
{
Console.Write("This is from Bar");
}
}
public class User
{
public void Use()
{
IFoo foo = new Census();
IBar bar = new Census();
foo.X();
// => "This is from Foo"
bar.X();
// => "This is from Bar"
}
}
Il existe plusieurs cas d'usage :
IEnumerable.GetEnumerator(), à côté de IEnumerable<T>.GetEnuerator(). Il se peut que tu n'utilises jamais cette interface, mais le compilateur peut l'exiger.IFormattable possède une méthode ToString() qui prend un paramètre format type ainsi qu'un paramètre de type IFormatProvider. Une classe comme FormattableString de la bibliothèque de classes de base (BCL) implémente l'interface pour pouvoir être utilisée par des routines qui prennent un IFormattable, mais il est plus expressif que sa version principale de ToString(IFormatProvider) omette le paramètre format type, car il n'est pas utilisé dans l'implémentation et ne ferait que désorienter les utilisateurs de l'API.La version 8 de C# répond à un problème lancinant des API. Si tu ajoutes des méthodes à une interface pour enrichir les fonctionnalités destinées aux nouvelles implémentations, il faut alors modifier toutes les implémentations existantes de l'interface pour qu'elles respectent le contrat de l'API, même si elles n'ont aucun comportement propre à implémenter. C# permet désormais de fournir une méthode par défaut directement dans l'interface (les développeurs Java connaissent bien ce principe). Auparavant, quand un tel changement survenait, une version 2 de l'interface venait s'ajouter à l'originale.
Cet article est une excellente introduction aux interfaces ; il traite en particulier de l'implémentation par défaut et d'autres nouveautés associées, comme les membres static, private et virtual.