Interfacce (introduzione) e implementazione di più interfacce
Definisca le interfacce come contratti, implementi più interfacce in un'unica classe, utilizzi il polimorfismo basato su interfacce e apprenda le basi dell'implementazione esplicita delle interfacce.
Interfacce (introduzione) e implementazione di più interfacce è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 2 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 3 lezioni in totale.
Panoramica sulle interfacce
Obiettivo: Programmare in base alle interfacce per ottenere codice flessibile.
- Le interfacce dichiarano che cosa, non come
- Implementare più interfacce
- Passare le interfacce alle funzioni
- Usare l'implementazione esplicita per risolvere i conflitti tra nomi
Implementare più interfacce
Le interfacce definiscono un contratto. Una classe può implementare più interfacce per esprimere ruoli diversi.
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);
}
}
Polimorfismo delle interfacce
Accetti un tipo interfaccia nei metodi. I chiamanti possono passare qualsiasi implementazione.
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"));
}
}
Implementazione esplicita
L'implementazione esplicita disambigua i membri con lo stesso nome e li nasconde dall'interfaccia della 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");
}
}
Raccolte di interfacce
Conservi implementazioni diverse in un elenco del tipo dell'interfaccia e le scorra in modo uniforme.
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
}
}
}
Suggerimenti sulle interfacce
Suggerimenti:
- Preferisca interfacce piccole che descrivono un solo ruolo.
- Usi le interfacce per i test (sostituendo le implementazioni).
- In C# 6 le interfacce non hanno campi né corpi dei metodi.
- Implementi più interfacce per comporre i comportamenti.
Concetto di interfaccia
Riepilogo
Riepilogo: Le interfacce sono contratti e supportano l'implementazione di più interfacce per classe. Passi le interfacce alle funzioni, le mantenga piccole e usi l'implementazione esplicita per risolvere i conflitti.
Domande Frequenti
La lezione «Interfacce (introduzione) e implementazione di più interfacce» è gratuita?
Sì — il testo completo di «Interfacce (introduzione) e implementazione di più interfacce» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 3 lezioni in totale.
Cosa imparerò in «Interfacce (introduzione) e implementazione di più interfacce»?
Definisca le interfacce come contratti, implementi più interfacce in un'unica classe, utilizzi il polimorfismo basato su interfacce e apprenda le basi dell'implementazione esplicita delle interfacce. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare C# Academy?
Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 3.
Quanto tempo richiede la lezione «Interfacce (introduzione) e implementazione di più interfacce»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione C# Academy?
Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- virtual/override/sealed e classi astratte
- Interfacce (introduzione) e implementazione di più interfacce
- Polimorfismo e dispatch dinamico