Delen via

Typen maken in C#

In deze zelfstudie leert u hoe u typen maakt 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.

Aanbeveling

Wanneer een codefragmentblok de knop Uitvoeren bevat, wordt het interactieve venster geopend of wordt de bestaande code in het interactieve venster vervangen. Wanneer het codefragment geen knop Uitvoeren bevat, kunt u de code kopiëren en toevoegen aan het huidige interactieve venster.

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.

Tuples

Tuples zijn een geordende reeks waarden met een vaste lengte. Elk element van een tuple heeft een type en een optionele naam. De volgende code declareert een tuple die een 2D-punt vertegenwoordigt. Selecteer de knop Uitvoeren om de volgende code in het interactieve venster te plakken en uit te voeren.

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}.");

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 in het interactieve venster om te zien wat u moet oplossen. Deze oefening helpt u de structuur van C#-code te leren.

U kunt elk lid van een tuple opnieuw toewijzen. Voeg de volgende code toe in het interactieve venster na de bestaande code. Druk nogmaals op Uitvoeren om de resultaten te bekijken.

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

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 code die al in het interactieve venster staat en druk op Uitvoeren 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. U kunt de volgende code toevoegen na de code die u al in het interactieve venster hebt geschreven en probeer het:

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

De variabele subscript heeft twee leden, beide gehele getallen. Beide subscript en pt vertegenwoordigen exemplaren van hetzelfde tupletype: een tuple met 2 int leden.

Tuples zijn eenvoudig te maken: u declareert meerdere leden tussen haakjes. Alle volgende declareren verschillende tuples van verschillende arities en lidtypen. 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);

Tuples zijn eenvoudig te maken, maar ze zijn 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 kunnen worden gedeclareerd zodra ze worden gebruikt. Naarmate uw programma verloopt, 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. Zodra u dat hebt gevonden, kunt u een record type declareren dat deze waarden opslaat en meer mogelijkheden biedt. In het volgende codevoorbeeld wordt een Main methode gebruikt om het toegangspunt voor het programma weer te geven. Op die manier kunt u een record type declareren dat voorafgaat aan het toegangspunt in de code. Druk op de knop Uitvoeren in de volgende code om uw bestaande voorbeeld te vervangen door de volgende code.

Waarschuwing

Kopieer en plak niet. Het interactieve venster moet opnieuw worden ingesteld om het volgende voorbeeld uit te voeren. Als u een fout maakt, loopt het venster vast en moet u de pagina vernieuwen om door te gaan.

De volgende code declareert en gebruikt een record type om een Pointte vertegenwoordigen en gebruikt vervolgens die Point structuur in de Main methode:

public record Point(int X, int Y);

public static void Main()
{
    Point pt = new Point(1, 1);
    var pt2 = pt with { Y = 10 };
    Console.WriteLine($"The two points are {pt} and {pt2}");
}

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 Main methode 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 pt2 = pt with { Y = 10 } zegt: 'pt2 heeft dezelfde waarden als pt behalve die Y is toegewezen aan 10'. U kunt een willekeurig aantal eigenschappen toevoegen om te wijzigen in één with expressie.

De voorgaande record verklaring is één regel code die eindigt op ;, zoals alle C#-instructies. 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. Vervang de recorddeclaratie die u hebt gemaakt door de volgende code:

public record Point(int X, int Y)
{
    public double Slope() => (double)Y / (double)X;
}

Voeg vervolgens de volgende code toe aan de Main methode na de regel met de with expressie:

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

U hebt formaliteit toegevoegd aan de tuple die een X en Y waarde vertegenwoordigt. U hebt een record gemaakt dat een benoemd type definieert en een lid bevat om de helling te berekenen. Een record type is een afkorting voor een record class: Een class type dat extra gedrag bevat. U kunt het Point type ook wijzigen om het te record struct maken:

public record struct Point(int X, int Y)
{
    public double Slope() => (double) Y / (double) X;
}

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

Struct-, klasse- en interface-types

Alle benoemde typen in C# zijn ofwel class-typen ofwel struct-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.

U gebruikt struct typen voor waardetypen wanneer meer geavanceerd gedrag nodig is, maar de primaire verantwoordelijkheid is het opslaan van waarden. U gebruikt 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 interactieve zelfstudie 'Typen maken in C#' voltooid. U kunt de koppeling Vertakkingen en lussen selecteren om de volgende interactieve zelfstudie te starten. U kunt ook de .NET-site bezoeken om de .NET SDK te downloaden, een project op uw computer te maken en coderen te behouden. In de sectie "Volgende stappen" wordt u teruggeleid naar deze tutorials.

Meer informatie over typen in C# vindt u in de volgende artikelen:

  • Last updated on