Delen via

Zelfstudie: Typen maken in C#

In deze handleiding leert u typen maken in C#. U schrijft kleine hoeveelheden code, vervolgens compileert en voert u die code uit. De zelfstudie bevat een reeks lessen die verschillende soorten typen in C# verkennen. In deze lessen leert u de basisprincipes van de C#-taal.

De voorgaande zelfstudies werkten met tekst en getallen. Tekenreeksen en getallen zijn eenvoudige typen: ze slaan elk één waarde op. Naarmate uw programma's groter worden, moet u werken met geavanceerdere gegevensstructuren. C# biedt verschillende typen die u kunt definiëren wanneer u gegevensstructuren nodig hebt met meer velden, eigenschappen of gedrag. Laten we deze typen gaan verkennen.

In deze handleiding leert u:

  • Tuple-typen maken en bewerken.
  • Recordtypen maken.
  • Meer informatie over struct-, klasse- en interfacetypen.

Vereiste voorwaarden

U moet een van de volgende opties hebben:

Als u codespaces wilt gebruiken, hebt u een GitHub-account nodig. Als u nog geen account hebt, kunt u een gratis account maken op GitHub.com.

Tuples

Als u een GitHub Codespace met de zelfstudieomgeving wilt starten, opent u een browservenster naar de opslagplaats van de zelfstudiecodespace . Selecteer de groene knop Code en het tabblad Codespaces . Selecteer vervolgens het + teken om een nieuwe Codespace te maken met behulp van deze omgeving. Als u andere zelfstudies in deze reeks hebt voltooid, kunt u die coderuimte openen in plaats van een nieuwe te maken.

  1. Wanneer uw codespace wordt geladen, maakt u een nieuw bestand in de map tutorials met de naam tuples.cs.

  2. Open het nieuwe bestand.

  3. Typ of kopieer de volgende code in tuples.cs:

    var pt = (X: 1, Y: 2);

var slope = (double)pt.Y / (double)pt.X;
Console.WriteLine($"A line from the origin to the point {pt} has a slope of {slope}.");

  4. Voer uw programma uit door de volgende opdrachten te typen in het geïntegreerde terminalvenster:

    cd tutorials
dotnet tuples.cs

    Tuples zijn een geordende reeks waarden met een vaste lengte. Elk element van een tuple heeft een type en een optionele naam.

    Aanbeveling

    Terwijl u C# (of een programmeertaal) verkent, maakt u fouten wanneer u code schrijft. De compiler vindt deze fouten en rapporteert deze aan u. Wanneer de uitvoer foutberichten bevat, bekijkt u de voorbeeldcode en de code om te zien wat u moet oplossen. U kunt Copilot ook vragen om verschillen te vinden of fouten te herkennen. Deze oefening helpt u de structuur van C#-code te leren.

  5. Voeg de volgende code toe na de vorige code om een tuple-lid te wijzigen:

    pt.X = pt.X + 5;
Console.WriteLine($"The point is now at {pt}.");

  6. U kunt ook een nieuwe tuple maken die een gewijzigde kopie van het origineel is met behulp van een with expressie. Voeg de volgende code toe na de bestaande code en typ dotnet tuples.cs in het terminalvenster om de resultaten te bekijken:

    var pt2 = pt with { Y = 10 };
Console.WriteLine($"The point 'pt2' is at {pt2}.");

    De tuple pt2 bevat de X waarde van pt 6, en pt2.Y is 10. Tuples zijn structurele typen. Met andere woorden, tuple-typen hebben geen namen zoals string of int. Een tupletype wordt gedefinieerd door het aantal leden, aangeduid als arity en de typen van die leden. De ledennamen zijn voor het gemak. U kunt een tuple toewijzen aan een tuple met dezelfde ariteit en typen, zelfs als de elementen verschillende namen hebben.

  7. U kunt de volgende code toevoegen na de code die u al hebt geschreven:

    var subscript = (A: 0, B: 0);
subscript = pt;
Console.WriteLine(subscript);

  8. Probeer het door in het terminalvenster te typen dotnet tuples.cs . De variabele subscript heeft twee leden, beide gehele getallen. Beide subscript en pt vertegenwoordigen exemplaren van hetzelfde tupletype: een tuple die twee int leden bevat.

    Tuples zijn eenvoudig te maken: u declareert meerdere leden tussen haakjes. Alle volgende declaraties definiëren verschillende tuples met verschillende ariteiten en lidtype.

  9. Voeg de volgende code toe om nieuwe tuple-typen te maken:

    var namedData = (Name: "Morning observation", Temp: 17, Wind: 4);
var person = (FirstName: "", LastName: "");
var order = (Product: "guitar picks", style: "triangle", quantity: 500, UnitPrice: 0.10m);

  10. Probeer deze wijziging door opnieuw te typen dotnet tuples.cs in het terminalvenster.

Hoewel tuples eenvoudig te maken zijn, zijn ze beperkt in hun mogelijkheden. Tuple-typen hebben geen namen, dus u kunt geen betekenis overbrengen naar de set waarden. Tuple-typen kunnen geen gedrag toevoegen. C# heeft andere soorten typen die u kunt maken wanneer uw type gedrag definieert.

Recordtypen maken

Tuples zijn ideaal voor die tijden wanneer u meerdere waarden in dezelfde structuur wilt hebben. Ze zijn lichtgewicht en u kunt ze declareren terwijl u ze gebruikt. Naarmate uw programma groeit, kunt u merken dat u hetzelfde tuple-type in uw code gebruikt. Als uw app werkt in de 2D-grafiekruimte, zijn de tuples die punten vertegenwoordigen mogelijk gemeenschappelijk. Wanneer u dit patroon vindt, kunt u een record type declareren dat deze waarden opslaat en meer mogelijkheden biedt.

  1. Voeg de volgende code toe om een record-type te declareren en te gebruiken als representatie van een Point.

    public record Point(int X, int Y);

    De voorgaande code moet onder aan het bronbestand staan. Typedeclaraties zoals record declaraties moeten uitvoerbare instructies volgen in een app op basis van bestanden.

  2. Voeg de volgende code toe voorafgaand aan de record declaratie:

    Point pt3 = new Point(1, 1);
var pt4 = pt3 with { Y = 10 };
Console.WriteLine($"The two points are {pt3} and {pt4}");

    De record declaratie is een enkele regel code voor het Point type, waarin de waarden X en Y worden opgeslagen in lees-eigenschappen. U gebruikt de naam Point waar u dat type ook gebruikt. Typen met een juiste naam, zoals Point, geven informatie over hoe het type wordt gebruikt. De aanvullende code laat zien hoe u een with expressie gebruikt om een nieuw punt te maken dat een gewijzigde kopie van het bestaande punt is. De regel pt4 = pt3 with { Y = 10 } zegt: 'pt4 heeft dezelfde waarden als pt3 behalve die Y is toegewezen aan 10'. U kunt een willekeurig aantal eigenschappen toevoegen om te wijzigen in één with expressie.

    De voorgaande record declaratie is één regel code die eindigt op ;. U kunt gedrag toevoegen aan een record type door leden te declareren. Een recordlid kan een functie of meer gegevenselementen zijn. De leden van een type bevinden zich in de typedeclaratie tussen { en } tekens.

  3. Verwijder de ; coderegels en voeg de volgende regels code toe na de record declaratie:

    {
    public double Slope() => (double)Y / (double)X;
}

  4. Voeg de volgende code toe vóór de record declaratie, na de regel met de with expressie:

    double slopeResult = pt4.Slope();
Console.WriteLine($"The slope of {pt4} is {slopeResult}");

  5. Typ dotnet tuples.cs in het terminalvenster om deze versie uit te voeren.

    U hebt formaliteit toegevoegd aan de tuple die een X en Y waarde vertegenwoordigt. U hebt er een record van gemaakt dat een benoemd type definieert en een lid opneemt om de helling te berekenen. Een record type is een afkorting voor een record class: Een class type dat extra gedrag bevat.

  6. U kunt het Point type ook wijzigen om het te record struct maken:

    public record struct Point(int X, int Y)

    A record struct is een struct type dat het extra gedrag bevat dat aan alle record typen wordt toegevoegd.

  7. Probeer deze versie door in het terminalvenster te typen dotnet tuples.cs .

Struct-, klasse- en interface-types

Alle concrete benoemde typen in C# zijn class of struct typen, inclusief record typen. A class is een verwijzingstype. A struct is een waardetype. Variabelen van een waardetype slaan de inhoud van de instantie direct op in het geheugen. Met andere woorden, een record struct Point slaat twee gehele getallen op: X en Y. Variabelen van een verwijzingstype slaan een verwijzing of aanwijzer op naar de opslag voor het exemplaar. Met andere woorden, een record class Point slaat een verwijzing op naar een blok geheugen met de waarden voor X en Y.

In de praktijk betekent dit dat waardetypen worden gekopieerd wanneer ze worden toegewezen, maar een kopie van een klasse-exemplaar een kopie van de verwijzing is. Deze gekopieerde verwijzing verwijst naar hetzelfde exemplaar van een punt, met dezelfde opslag voor X en Y.

De record modifier geeft de compiler de opdracht om verschillende leden voor u te schrijven. Meer informatie vindt u in het artikel over recordtypen in de sectie Grondbeginselen.

Wanneer u een record type declareert, declareert u dat uw type een standaardset gedrag moet gebruiken voor gelijkheidsvergelijkingen, toewijzingen en het kopiëren van exemplaren van dat type. Records zijn de beste keuze wanneer het de primaire verantwoordelijkheid van uw type is om gerelateerde gegevens op te slaan. Wanneer u meer gedrag toevoegt, kunt u overwegen om struct- of class-typen te gebruiken, zonder de record-modifier.

Gebruik struct typen voor waardetypen wanneer u geavanceerder gedrag nodig hebt, maar de primaire verantwoordelijkheid is het opslaan van waarden. Gebruik class typen om objectgeoriënteerde idiomen te gebruiken, zoals inkapseling, overname en polymorfisme.

U kunt ook typen definiëren interface om gedragscontracten te declareren die door verschillende typen moeten worden geïmplementeerd. Beide struct en class typen kunnen interfaces implementeren.

Doorgaans gebruikt u al deze typen in grotere programma's en bibliotheken. Zodra u de .NET SDK hebt geïnstalleerd, kunt u deze typen verkennen met behulp van zelfstudies over klassen in de sectie Basisprincipes.

U hebt de cursus "Typen maken in C#" voltooid. Meer informatie over typen in C# vindt u in de volgende artikelen:

Middelen opschonen

GitHub verwijdert uw Codespace automatisch na 30 dagen inactiviteit. Als u van plan bent om meer tutorials uit deze serie te volgen, kunt u uw Codespace geconfigureerd laten. Als u klaar bent om naar de .NET-site te gaan om de .NET SDK te downloaden, kunt u uw Codespace verwijderen. Als u uw Codespace wilt verwijderen, opent u een browservenster en gaat u naar uw Codespaces. U ziet nu een lijst met uw coderuimten in het venster. Selecteer de drie puntjes (...) in de vermelding voor de zelfstudiecoderuimte en selecteer Verwijderen.

Volgende stap

Vertakkingen en lussen

  • Last updated on