C# Academy · Lektion

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.

Lektion 2 av 38 steg

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

Snabb kontroll: Vilket påstående om gränssnitt i C# är korrekt?

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.

Gratis att börja

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

  1. virtual/override/sealed och abstrakta klasser
  2. Gränssnitt (introduktion) och implementering av flera gränssnitt
  3. Polymorfism och dynamisk dispatch
← Tillbaka till C# Academy