Generiska gränssnitt
Abstrahera över typer.
Generiska gränssnitt är en gratis lektion i C# Academy på CoddyKit. Detta är lektion 4 av 4. 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 4 lektioner.
Vad är ett generiskt gränssnitt?
Ett generiskt gränssnitt deklarerar typparametrar i vinkelparenteser efter namnet. Implementerare väljer de konkreta typerna, och gränssnittskontraktet anpassas därefter.
.NET-biblioteket använder dem överallt, till exempel IEnumerable<T> och IComparable<T>.
interface IRepository<T>
{
void Add(T item);
T Get(int id);
}Implementera ett generiskt gränssnitt
En klass kan implementera ett generiskt gränssnitt genom att ange ett konkret typargument. Metodsignaturerna använder då den konkreta typen.
Detta ger ett typsäkert och återanvändbart kontrakt utan typkonverteringar.
using System.Collections.Generic;
class IntStore : IRepository<int>
{
private readonly List<int> data = new();
public void Add(int item) => data.Add(item);
public int Get(int id) => data[id];
}
interface IRepository<T>
{
void Add(T item);
T Get(int id);
}Förbli generisk i implementeringen
En klass kan implementera ett generiskt gränssnitt och samtidigt själv förbli generisk genom att vidarebefordra sin egen typparameter till gränssnittet.
Detta håller implementeringen återanvändbar för alla elementtyper.
using System.Collections.Generic;
class Store<T> : IRepository<T>
{
private readonly List<T> data = new();
public void Add(T item) => data.Add(item);
public T Get(int id) => data[id];
}
interface IRepository<T> { void Add(T item); T Get(int id); }IComparable<T> i praktiken
IComparable<T> är ett inbyggt generiskt gränssnitt. Genom att implementera det kan typen definiera hur instanser ordnas, vilket möjliggör sortering.
Metoden CompareTo returnerar ett negativt värde, noll eller ett positivt värde.
class Money : IComparable<Money>
{
public int Cents;
public int CompareTo(Money? other)
=> Cents.CompareTo(other?.Cents ?? 0);
}Implementera IEnumerable<T>
IEnumerable<T> är kärnan i LINQ och foreach. En typ som implementerar det kan itereras. Ofta delegerar Ni till iteratorn i en inre samling.
Iterator-metoder med yield return gör detta enkelt.
using System.Collections;
using System.Collections.Generic;
class Bag<T> : IEnumerable<T>
{
private readonly List<T> items = new();
public void Add(T x) => items.Add(x);
public IEnumerator<T> GetEnumerator() => items.GetEnumerator();
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}Ett körbart generiskt gränssnitt
Detta kompletta program definierar ett generiskt IPrinter<T>, implementerar det för strängar och använder det sedan.
Gränssnittet garanterar en Print-metod oavsett den konkreta typen.
using System;
interface IPrinter<T> { void Print(T value); }
class ConsolePrinter<T> : IPrinter<T>
{
public void Print(T value) => Console.WriteLine(value);
}
class Program
{
static void Main()
{
IPrinter<string> p = new ConsolePrinter<string>();
p.Print("hello generics");
}
}Kovarians med out
En typparameter i ett generiskt gränssnitt som markerats med out är kovariant: den förekommer endast i utdata-positioner. Detta gör att IEnumerable<Cat> kan användas där IEnumerable<Animal> förväntas.
Kovarians bevarar tilldelningskompatibilitet längs en arvskedja.
interface IProducer<out T>
{
T Produce();
}Kontravarians med in
En parameter som markerats med in är kontravariant: den förekommer endast i indata-positioner. Detta gör att en IComparer<Animal> kan användas där en IComparer<Cat> behövs.
Kontravarians vänder riktningen för tilldelningskompatibilitet hos konsumenter.
interface IConsumer<in T>
{
void Consume(T item);
}Flera typparametrar
Generiska gränssnitt kan ta emot fler än en parameter. IDictionary<TKey, TValue> är ett välkänt exempel med separata nyckel- och värdetyper.
Varje parameter kan oberoende av de andra vara invariant, kovariant eller kontravariant.
interface IMapper<TIn, TOut>
{
TOut Map(TIn input);
}Programmering mot gränssnittet
Att förlita sig på ett generiskt gränssnitt i stället för en konkret klass gör koden flexibel. Implementeringar kan bytas ut utan att den anropande koden behöver ändras.
Metodparametrar av typen IEnumerable<T> accepterar både listor, arrayer och frågeresultat.
using System.Collections.Generic;
using System.Linq;
int Total(IEnumerable<int> values) => values.Sum();Typbegränsningar med generiska gränssnitt
Generiska gränssnitt används ofta som typbegränsningar. where T : IComparable<T> gör att en metod kan sortera eller jämföra sina indatavärden.
Detta kombinerar två funktioner hos generiska typer för att skapa säkra och återanvändbara algoritmer.
T Min<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) <= 0 ? a : b;Snabb kontroll
Testa er förståelse av generiska gränssnitt.
Sammanfattning
Generiska gränssnitt deklarerar typparametrar och låter implementerare fastställa eller vidarebefordra dem. Inbyggda exempel är IEnumerable<T>, IComparable<T> och IDictionary<TKey, TValue>.
Variansattributen out och in möjliggör kovarians och kontravarians, och generiska gränssnitt passar naturligt ihop med where-begränsningar.
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 ”Generiska gränssnitt” gratis?
Ja – hela texten till ”Generiska 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 4 lektioner.
Vad lär jag mig i ”Generiska gränssnitt”?
Abstrahera över typer. 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 4 av 4.
Hur lång tid tar lektionen ”Generiska 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
- Generiska metoder
- Generiska klasser
- where-begränsningar
- Generiska gränssnitt