Skapa inkapslade data med structs i C#

Slutförd

När du arbetar med projektet för att spåra orderinformation behöver du ett sätt att hålla ihop relaterad information som kundens namn, leveransadress och ordersumma. Med Structs i C# kan du skapa en grundläggande inkapslad container för dessa data, vilket gör det enklare att arbeta med och skicka runt som en enda enhet.

Förstå strukturer

Structs är värdetyper i C#, vilket innebär att de lagrar sina data direkt i stället för att referera till dem. Du använder nyckelordet struct för att definiera en struct. Structs används vanligtvis för små, datacentrerade typer som ger minimalt beteende.

• Structs har värdesemantik, vilket innebär att deras värden kopieras under tilldelnings- eller metodanrop.
• Vanliga användningsfall är att representera tal, booleska värden, tecken och tidsinstanser.
• Structs används ofta för att representera lätta data som geometriska former (till exempel Rectangle, Circle), koordinater eller konfigurationsinställningar.

Structs passar bäst för små, oföränderliga och prestandakritiska data. Överväg att använda klasser i stället för större, mer komplexa objekt eller när beteendet är i fokus. Till skillnad från klasser kan structs inte ärva från andra structs eller klasser, men de kan implementera gränssnitt.

Tips/Råd

Om din typ fokuserar på beteende snarare än data är klasser ofta ett bättre val på grund av deras referenssemantik.

Definiera och implementera en struct

public struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

Kodexempel visar hur du definierar en struct med fält och en konstruktor i C#.

Structs kan också implementera gränssnitt men kan inte ärva från andra klasser eller structs.

Kapsla in data med strukturer

Med inkapsling kan du styra åtkomsten till data i en struct. Använd åtkomstmodifierare som private, public eller internal för att specificera åtkomst.

• Fält och egenskaper kan göras privata för att begränsa direkt åtkomst.
• Metoder kan ge kontrollerade sätt att interagera med data.

Till exempel:

public struct Rectangle
{
    private int width;
    private int height;

    public Rectangle(int width, int height)
    {
        this.width = width;
        this.height = height;
    }

    public int Area => width * height;
}

Kodexempel visar en struct i C# med inkapslade fält och en beräknad egenskap för området.

Tillämpa readonly-modifierare på structs för oföränderlighet

Oföränderlighet säkerställer att dess data inte kan ändras när en struct har skapats. En struct är användbar när du arbetar med data som ska förbli konstanta under hela dess livslängd, till exempel koordinater eller konfigurationsvärden. När du tillämpar modifieraren på readonly en struct kan du framtvinga oföränderlighet, vilket gör koden mer förutsägbar och mindre utsatt för fel som orsakas av oavsiktliga ändringar.

public readonly struct ImmutablePoint
{
    public int X { get; init; }
    public int Y { get; init; }

    public ImmutablePoint(int x, int y)
    {
        X = x;
        Y = y;
    }
}

Kodexempel visar hur modifieraren används readonly för att skapa en oföränderlig struct i C#.

Anmärkning

Även om själva structen är oföränderlig kan föränderliga referenstyper i den fortfarande ändra deras tillstånd.

Använda objektinitierare med structs

När du arbetar med structs behöver du ofta initiera flera egenskaper. Objektinitierare ger ett enkelt och läsbart sätt att skapa och initiera struct-instanser i ett enda steg. Den här metoden minskar repetitiv kod och gör avsikten tydlig.

Följande kodexempel definierar en struct med egenskaper som grupperar relaterade data tillsammans och gör det enklare att initiera och arbeta med instanser av structen.

public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

Med hjälp av en objektinitierare kan du skapa och initiera en Point:

var point = new Point { X = 10, Y = 20 };

Kodexempel visar hur du använder en objektinitierare för att ange egenskapsvärden när du skapar en struct-instans.

Tips/Råd

Objektinitierare gör koden mer koncis och enklare att läsa när du arbetar med structs som har flera egenskaper.

Praktiskt exempel: Använda structs för att representera punkter i 2D-utrymme

Structs används ofta för att representera små, oföränderliga datastrukturer. Du kan till exempel använda en struct för att representera en punkt i 2D-utrymme och beräkna avståndet mellan två punkter:

public struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    public double DistanceTo(Point other)
    {
        int dx = X - other.X;
        int dy = Y - other.Y;
        return Math.Sqrt(dx * dx + dy * dy);
    }
}

var point1 = new Point(3, 4);
var point2 = new Point(7, 1);
Console.WriteLine($"Distance between points: {point1.DistanceTo(point2)}");

Det här exemplet visar hur du definierar en struct för en punkt, beräknar avståndet mellan två punkter och använder struct i ett enkelt program.

Genom att kombinera inkapsling, oföränderlighet och objektinitierare kan du skapa strukturer som är effektiva och förutsägbara. De här funktionerna hjälper dig att hantera relaterade data på ett rent och organiserat sätt.