Gränssnitt (introduktion) och implementering av flera gränssnitt
Definiera gränssnitt som kontrakt, implementera flera gränssnitt i en klass, använd gränssnittsbaserad polymorfism och lär er grunderna i explicit gränssnittsimplementation.
Gränssnitt (introduktion) och implementering av flera gränssnitt är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 2 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C# Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C# Academy innehåller totalt 3 lektioner.
Översikt över gränssnitt
Mål: Programmera mot gränssnitt för flexibel kod.
- Gränssnitt deklarerar vad, inte hur
- Implementera flera gränssnitt
- Skicka gränssnitt till funktioner
- Explicit implementering löser namnkonflikter
Implementera flera gränssnitt
Gränssnitt definierar ett kontrakt. En klass kan implementera flera gränssnitt för att uttrycka olika roller.
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);
}
}
Gränssnittspolymorfism
Låt metoder ta emot en gränssnittstyp. Anropande kod kan skicka valfri implementation.
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"));
}
}
Explicit implementering
Explicit implementering skiljer mellan medlemmar med samma namn och döljer dem från klassens yttre gränssnitt.
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");
}
}
Samlingar av gränssnitt
Lagra olika implementationer i en lista av gränssnittstypen och iterera över dem på ett enhetligt sätt.
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
}
}
}
Tips för gränssnitt
Tips:
- Föredra små gränssnitt som beskriver en enda roll.
- Använd gränssnitt vid testning för att kunna byta implementationer.
- I C# 6 har gränssnitt inga fält eller metodkroppar.
- Implementera flera gränssnitt för att kombinera beteenden.
Begreppet gränssnitt
Sammanfattning
Sammanfattning: Gränssnitt är kontrakt och stödjer att varje klass implementerar flera gränssnitt. Skicka gränssnitt till funktioner, håll dem små och använd explicit implementering för att lösa konflikter.
Lär dig C# med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 93
- Lektioner
- 346
Vanliga frågor
Är lektionen ”Gränssnitt (introduktion) och implementering av flera gränssnitt” gratis?
Ja – hela texten till ”Gränssnitt (introduktion) och implementering av flera gränssnitt” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C# Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C# Academy innehåller totalt 3 lektioner.
Vad lär jag mig i ”Gränssnitt (introduktion) och implementering av flera gränssnitt”?
Definiera gränssnitt som kontrakt, implementera flera gränssnitt i en klass, använd gränssnittsbaserad polymorfism och lär er grunderna i explicit gränssnittsimplementation. Ni övar på C# Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig C# Academy?
Du behöver inga förkunskaper. Utbildningen i C# Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 3.
Hur lång tid tar lektionen ”Gränssnitt (introduktion) och implementering av flera gränssnitt”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här C# Academy-lektionen?
Ja. Varje C# Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- virtual/override/sealed och abstrakta klasser
- Gränssnitt (introduktion) och implementering av flera gränssnitt
- Polymorfism och dynamisk dispatch