Interfaces (introduktion) og implementering af flere interfaces
Definér interfaces som kontrakter, implementér flere interfaces i én klasse, brug interface-baseret polymorfi, og lær det grundlæggende i eksplicit interface-implementering.
Interfaces (introduktion) og implementering af flere interfaces er en gratis C# Academy-lektion på CoddyKit. Dette er lektion 2 af 3. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i C# Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. C# Academy-kurset indeholder 3 lektioner i alt.
Oversigt over grænseflader
Mål: Programmér mod grænseflader for at få fleksibel kode.
- Grænseflader erklærer hvad, ikke hvordan
- Implementér flere grænseflader
- Send grænseflader til funktioner
- Eksplicit implementering løser navnekonflikter
Implementering af flere grænseflader
Grænseflader definerer en kontrakt. En klasse kan implementere flere grænseflader for at udtrykke forskellige 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ænsefladepolymorfi
Acceptér en grænsefladetype i metoder. Kaldende kode kan sende enhver implementering.
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"));
}
}
Eksplicit implementering
Eksplicit implementering skelner mellem medlemmer med samme navn og skjuler dem fra klassens offentlige grænseflade.
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");
}
}
Samlinger af grænseflader
Gem forskellige implementeringer i en liste af grænsefladetypen, og gennemløb den ensartet.
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
}
}
}
Tip til grænseflader
Tip:
- Foretræk små grænseflader, der beskriver én rolle.
- Brug grænseflader til afprøvning (udskift implementeringer).
- I C# 6 har grænseflader ingen felter eller metodekroppe.
- Implementér flere grænseflader for at kombinere adfærd.
Begrebet grænseflader
Opsamling
Opsamling: Grænseflader er kontrakter og understøtter flere implementeringer pr. klasse. Send grænseflader til funktioner, hold dem små, og brug eksplicit implementering til at løse konflikter.
Lær C# med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 93
- Lektioner
- 346
Ofte stillede spørgsmål
Er lektionen “Interfaces (introduktion) og implementering af flere interfaces” gratis?
Ja — hele teksten til “Interfaces (introduktion) og implementering af flere interfaces” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af C# Academy-kurset, skal du opgradere til CoddyKit PRO. C# Academy-kurset indeholder 3 lektioner i alt.
Hvad lærer jeg i “Interfaces (introduktion) og implementering af flere interfaces”?
Definér interfaces som kontrakter, implementér flere interfaces i én klasse, brug interface-baseret polymorfi, og lær det grundlæggende i eksplicit interface-implementering. Du øver dig i C# Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på C# Academy?
Der kræves ingen tidligere erfaring. C# Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 3.
Hvor lang tid tager lektionen “Interfaces (introduktion) og implementering af flere interfaces”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne C# Academy-lektion?
Ja. Alle C# Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- virtual/override/sealed; abstrakte klasser
- Interfaces (introduktion) og implementering af flere interfaces
- Polymorfi og dynamisk dispatch