Generics i C#

Generiske typer i C#

Velkommen til den første lektion i "Avancerede C#-funktioner"! I denne lektion lærer du om generiske typer, en effektiv funktion i C#, der giver dig mulighed for at oprette fleksibel og genanvendelig kode. Lad os komme i gang!

Generiske typer er en funktion i C#, der giver dig mulighed for at definere klasser, metoder og datastrukturer med en pladsholder for den datatype, de gemmer eller bruger. Generiske typer sikrer typesikkerhed og genbrug af kode.

Eksempel: En generisk liste (List<T>) kan gemme elementer af enhver type og samtidig sikre typesikkerhed.

Du kan definere en generisk klasse ved hjælp af syntaksen <T>, hvor T repræsenterer en typeparameter. Eksempel:

Vigtigt: Brug generiske typer til at oprette klasser, der fungerer med alle datatyper, samtidig med at typesikkerheden bevares.

using System;

class GenericBox<T> {
    public T Value { get; set; }

    public void Display() {
        Console.WriteLine("Value: " + Value);
    }
}

class Program {
    static void Main() {
        GenericBox<int> intBox = new GenericBox<int> { Value = 42 };
        intBox.Display(); // Outputs: Value: 42

        GenericBox<string> stringBox = new GenericBox<string> { Value = "Hello, Generics!" };
        stringBox.Display(); // Outputs: Value: Hello, Generics!
    }
}

Du kan definere en generisk metode i en klasse. Eksempel:

Tip: Brug generiske metoder til operationer, der gælder for flere datatyper.

using System;

class Program {
    static void Main() {
        PrintValue(42);
        PrintValue("Generics are powerful!");
    }

    static void PrintValue<T>(T value) {
        Console.WriteLine("Value: " + value);
    }
}

Begrænsninger indskrænker, hvilke typer der kan bruges som typeparametre. Eksempel:

• where T : struct - T skal være en værditype.
• where T : class - T skal være en referencetype.
• where T : new() - T skal have en parameterløs konstruktør.

Eksempel:

Vigtigt: Begrænsninger gør generiske typer mere fleksible og anvendelige i bestemte situationer.

using System;

class Program {
    static void Main() {
        DisplayDefault<int>();
        DisplayDefault<string>();
    }

    static void DisplayDefault<T>() where T : new() {
        T instance = new T();
        Console.WriteLine("Created instance of: " + typeof(T));
    }
}

C# indeholder flere indbyggede generiske samlinger:

• List<T>: Gemmer en samling elementer i et dynamisk array.
• Dictionary<TKey, TValue>: Gemmer nøgle-værdi-par, så opslag kan udføres hurtigt.
• Queue<T>: Implementerer en først ind, først ud-struktur (FIFO).

Eksempel: Brug af en generisk liste:

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        List<string> names = new List<string> { "Alice", "Bob", "Charlie" };
        names.Add("Diana");

        foreach (string name in names) {
            Console.WriteLine(name);
        }
    }
}

Opret en generisk klasse Pair<TKey, TValue>, der gemmer et nøgle-værdi-par, samt en generisk metode Swap(), der bytter om på nøglen og værdien. Eksempel:

using System;

class Pair<TKey, TValue> {
    public TKey Key { get; set; }
    public TValue Value { get; set; }

    public void Swap() {
        (Key, Value) = ((TKey)(object)Value, (TValue)(object)Key);
    }

    public void Display() {
        Console.WriteLine($"Key: {Key}, Value: {Value}");
    }
}

class Program {
    static void Main() {
        Pair<string, int> pair = new Pair<string, int> { Key = "Age", Value = 30 };
        pair.Display();
        pair.Swap();
        pair.Display();
    }
}

Her er nogle anbefalinger:

• Brug generiske typer til at oprette genanvendelige og typesikre klasser og metoder.
• Anvend begrænsninger, når der er behov for bestemte typekrav.
• Foretræk generiske samlinger frem for ikke-generiske samlinger af hensyn til ydeevne og sikkerhed.

Tip: Brug meningsfulde navne til typeparametre, f.eks. T for type eller TKey og TValue for nøgle-værdi-par.

Tillykke! Du har lært at bruge generiske typer til at skabe genanvendelig og fleksibel kode i C#. I næste lektion udforsker vi asynkron programmering med async og await. Lad os fortsætte med at kode!