C# Academy · leksjon

Verdi-likhet og dekomponering

Forstå strukturell likhet for records, overstyr Equals/GetHashCode, og bruk dekomponeringsmønstre.

Leksjon 3 av 412 trinn

Verdi-likhet og dekomponering er en gratis leksjon i C# Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i C# Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i C# Academy inneholder totalt 4 leksjoner.

Fordypning i record-likhet

Records genererer automatisk Equals, GetHashCode og operatorene ==/!=, som sammenligner alle egenskaper strukturelt. Når De forstår hvordan dette fungerer, kan De bruke records riktig og overstyre likheten ved behov.

Slik fungerer automatisk generert likhet

Kompilatoren genererer kode som sammenligner hver egenskap ved hjelp av EqualityComparer<T>.Default. For egenskaper av referansetype bruker dette egenskapenes egen Equals – ikke referanselikhet.

public record Address(string Street, string City);
public record Person(string Name, Address HomeAddress);

var a = new Person("Alice", new Address("123 Main", "NYC"));
var b = new Person("Alice", new Address("123 Main", "NYC"));

Console.WriteLine(a == b); // True — deep structural equality
// Equality checks:
// Name: "Alice" == "Alice" ✓
// HomeAddress: compares Address properties recursively ✓

Overstyre generert likhet

De kan overstyre Equals og GetHashCode på en record når De ønsker egendefinert logikk for likhet – for eksempel ved å sammenligne bare et utvalg av egenskapene.

public record Customer(int Id, string Name, string Email)
{
    // Consider customers equal if they have the same ID,
    // regardless of name or email changes
    public virtual bool Equals(Customer? other)
        => other is not null && Id == other.Id;

    public override int GetHashCode() => Id.GetHashCode();
}

Records i samlinger

Fordi records implementerer IEquatable<T> med strukturell likhet, fungerer de riktig som nøkler i ordbøker, i HashSet-er og med LINQ-metodene Distinct og GroupBy.

public record Tag(string Name, string Color);

var tags = new List<Tag>
{
    new("C#", "blue"), new("C#", "blue"), new("dotnet", "purple")
};

var unique = tags.Distinct().ToList(); // [Tag(C#, blue), Tag(dotnet, purple)]

var set = new HashSet<Tag>(tags);
set.Contains(new Tag("C#", "blue")); // true

Dekonstruering: Grunnleggende

Posisjonelle records genererer automatisk en Deconstruct-metode med out-parametere for hver posisjonelle egenskap. Dette muliggjør utpakking på samme måte som med tupler.

public record Point(double X, double Y);
public record RGB(byte R, byte G, byte B);

var p = new Point(3.0, 4.0);
var (x, y) = p; // deconstruct
Console.WriteLine($"{x}, {y}");

var color = new RGB(255, 128, 0);
var (r, g, b) = color;
Console.WriteLine($"R={r}, G={g}, B={b}");

Dekonstruering i mønstergjenkjenning

Records som dekonstrueres i switch-uttrykk, muliggjør kraftig posisjonsbasert mønstergjenkjenning.

public record Point(int X, int Y);

string Classify(Point p) => p switch
{
    (0, 0)           => "Origin",
    (int x, 0)       => $"X-axis at {x}",
    (0, int y)       => $"Y-axis at {y}",
    (int x, int y) when x == y => $"Diagonal at {x}",
    (int x, int y)   => $"Point ({x}, {y})"
};

Console.WriteLine(Classify(new Point(0, 0)));  // Origin
Console.WriteLine(Classify(new Point(3, 3)));  // Diagonal at 3

Egendefinerte Deconstruct-metoder

Ikke-posisjonelle records (og alle klasser) kan legge til en Deconstruct-metode manuelt. Utvidelsesmetoder kan også legge til dekonstruering for eksisterende typer.

public class Temperature
{
    public double Celsius { get; }
    public Temperature(double c) => Celsius = c;

    // Manual Deconstruct
    public void Deconstruct(out double celsius, out double fahrenheit)
    {
        celsius    = Celsius;
        fahrenheit = Celsius * 9 / 5 + 32;
    }
}

var t = new Temperature(100);
var (c, f) = t;
Console.WriteLine($"{c}°C = {f}°F"); // 100°C = 212°F

Ignorere deler av dekonstrueringen

Bruk forkastinger (_) til å ignorere uønskede deler av en dekonstruering – på samme måte som forkastinger for tupler.

public record Order(int Id, string Customer, decimal Total, DateTime Date);

var order = new Order(42, "Alice", 99.99m, DateTime.UtcNow);

// Only want Id and Total
var (id, _, total, _) = order;
Console.WriteLine($"Order {id}: ${total}");

// In switch: ignore some fields
string Classify(Order o) => o switch
{
    (_, _, > 1000, _) => "High value",
    (_, _, > 100, _)  => "Medium value",
    _                 => "Low value"
};

Egenskapsmønstre kontra posisjonsmønstre

Records støtter både posisjonsmønstre (etter posisjon) og egenskapsmønstre (etter navn). Egenskapsmønstre er mer lesbare for records med mange egenskaper.

public record Order(int Id, string Status, decimal Total);

// Positional pattern:
string DescribePos(Order o) => o switch
{
    (_, "Shipped", > 100) => "High-value shipped",
    _                     => "Other"
};

// Property pattern (more readable):
string DescribeProp(Order o) => o switch
{
    { Status: "Shipped", Total: > 100 } => "High-value shipped",
    { Status: "Cancelled" }             => "Cancelled",
    _                                   => "Other"
};

Fra virkeligheten: Result Type-mønsteret

En resultattype i stil med en diskriminert union, bygget med records og dekonstruering – en funksjonell tilnærming til feilhåndtering.

public abstract record Result<T>;
public record Success<T>(T Value) : Result<T>;
public record Failure<T>(string Error) : Result<T>;

Result<Order> PlaceOrder(CreateOrderRequest req)
{
    if (req.Quantity <= 0)
        return new Failure<Order>("Quantity must be positive");
    var order = CreateOrder(req);
    return new Success<Order>(order);
}

// Consuming:
var result = PlaceOrder(request);
switch (result)
{
    case Success<Order>(var order):
        return Results.Created($"/orders/{order.Id}", order);
    case Failure<Order>(var error):
        return Results.BadRequest(error);
}

Kort kontroll

Hva gjør bruk av en forkasting (_) i et dekonstrueringsuttrykk?

Besvar den i den interaktive leksjonen

Oppsummering: Verdilikhet og dekonstruering

Viktigste punkter:

Automatisk generert likhet sammenligner alle egenskaper strukturelt og rekursivt
Overstyr Equals/GetHashCode i records for egendefinert identitetslogikk
Records fungerer korrekt som elementer i HashSet og som ordboknøkler
Posisjonelle records genererer automatisk Deconstruct — bruk var (a, b) = record
Discard-verdier (_) ignorerer uønskede posisjonsverdier ved dekomponering
Egenskapsmønstre ({Status: "X"}) er mer lesbare enn posisjonelle mønstre for komplekse records

Gratis å komme i gang

Lær deg C# med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 93
Leksjoner: 346

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Verdi-likhet og dekomponering» gratis?

Ja – hele teksten i «Verdi-likhet og dekomponering» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av C# Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i C# Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Verdi-likhet og dekomponering»?

Forstå strukturell likhet for records, overstyr Equals/GetHashCode, og bruk dekomponeringsmønstre. Du øver på C# Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med C# Academy?

Ingen tidligere erfaring er nødvendig. C# Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Verdi-likhet og dekomponering»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne C# Academy-leksjonen?

Ja. Alle C# Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til C# Academy