Le interfaces sono il mezzo principale per disaccoppiare gli usi di una classe dalla sua implementazione. Questo disaccoppiamento offre flessibilità nella manutenzione dell'implementazione ed aiuta a supportare un comportamento generico sicuro rispetto ai tipi.
La sintassi di un'interfaccia è simile a quella di una classe o di una struct, con la differenza che i metodi e le proprietà compaiono solo come firma e non viene fornito alcun corpo.
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 o la struct che implementa un'interfaccia deve implementare tutte le operazioni definite da quell'interfaccia.
Di solito le interfacce fanno una o più delle seguenti cose:
IComparable<T>) oppurepublic 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();
}
}
Il codice che usa le interfacce e le classi qui sopra può:
Le interfacce sono molto usate per supportare i test, perché consentono un facile mocking.
Vedi questo articolo per i dettagli sui tipi di membro che possono essere inclusi in un'interfaccia.
Le interfacce possono ereditare da altre interfacce.
I membri di un'interfaccia sono pubblici per impostazione predefinita.
Le interfacce possono contenere tipi annidati, come valori letterali const, enums, delegates, classes e structs. In questo caso le interfacce fungono da namespace allo stesso modo delle classi e delle struct, ed il comportamento e la sintassi sono identici.
Per scelta progettuale, C# non supporta l'ereditarietà multipla, ma facilita una forma di ereditarietà multipla tramite le interfacce.
Inoltre, il meccanismo delle interfacce si fonda sull'idea che il polimorfismo può essere implementato tramite le interfacce.
A volte nomi e firme dei metodi possono essere condivisi tra due interfacce diverse. Per fornire un'implementazione distinta di questi metodi, C# offre l'implementazione esplicita delle interfacce. Tieni presente che per usare una particolare implementazione di un'interfaccia devi convertire a quell'interfaccia l'espressione che fa riferimento all'oggetto. Ci riesci con un'assegnazione, un cast o passandolo come parametro.
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"
}
}
Ci sono diversi casi d'uso:
IEnumerable.GetEnumerator(), accanto a IEnumerable<T>.GetEnuerator(). Potresti non usare mai quell'interfaccia, ma il compilatore potrebbe insistere.IFormattable ha un metodo ToString() che accetta un parametro format type oltre a un parametro di tipo IFormatProvider. Una classe come FormattableString della Base Class Library (BCL) implementa l'interfaccia per garantire che possa essere usata da routine che accettano un IFormattable, ma per la sua versione principale di ToString(IFormatProvider) è più espressivo omettere il parametro format type, dato che non viene usato nell'implementazione e confonderebbe chi usa l'API.La versione 8 di C# affronta un problema fastidioso delle API. Se aggiungi metodi ad un'interfaccia per ampliare le funzionalità a disposizione delle nuove implementazioni, devi modificare tutte le implementazioni esistenti dell'interfaccia perché rispettino il contratto dell'API, anche se non hanno alcun comportamento specifico da implementare. Ora C# permette di fornire un metodo predefinito come parte dell'interfaccia (chi sviluppa in Java lo conosce bene). In precedenza, quando avveniva un cambiamento del genere, una versione 2 dell'interfaccia esisteva accanto a quella originale.
Questo articolo è un'ottima introduzione alle interfacce e si concentra sull'implementazione predefinita e su altre innovazioni di supporto, come i membri static, private e virtual.