Tracce
/
C#
C#
/
Programma
/
Interfacce
In

Interfacce in C#

2 esercizi

Informazioni su Interfacce

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:

  • permettono al codice che le usa di trattare in modo generico classi diverse. In questo caso svolgono lo stesso ruolo di una classe base
  • espongono un sottoinsieme di funzionalità per uno scopo specifico (come IComparable<T>) oppure
  • espongono l'API pubblica di una classe in modo che più implementazioni possano coesistere. Un esempio è quello di un test double
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();
    }
}

Il codice che usa le interfacce e le classi qui sopra può:

  • trattare tutti i parlanti allo stesso modo, indipendentemente dalla lingua.
  • permettere ad un sottosistema che gestisce la conversione degli alfabeti di funzionare senza preoccuparsi dei tipi specifici con cui ha a che fare.
  • restare all'oscuro delle modifiche apportate al parlante italiano, cosa comoda se il codice delle classi e il codice che le usa sono mantenuti da team diversi

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.

Implementazione esplicita delle 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:

  • Un conflitto tra domini (come nell'esempio qui sopra), in cui i metodi hanno firme identiche.
  • Metodi con lo stesso nome ma con tipi restituiti diversi: se implementi le tue classi di raccolte, potresti scoprire che serve un'interfaccia esplicita per il metodo legacy IEnumerable.GetEnumerator(), accanto a IEnumerable<T>.GetEnuerator(). Potresti non usare mai quell'interfaccia, ma il compilatore potrebbe insistere.
  • Metodi in cui non c'è alcun conflitto di nomi tra le interfacce, ma è desiderabile che la classe che li implementa usi il nome per uno scopo correlato: 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.

Implementazione predefinita

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.

Modifica tramite GitHub Il collegamento si apre in una nuova finestra o scheda

Impara Interfacce

La pratica è bloccata

Sblocca un altro esercizio per esercitarti su Interfacce