C#-expressies

Tip

Dit artikel maakt deel uit van de sectie Grondbeginselen voor ontwikkelaars die al ten minste één programmeertaal kennen en C# leren. Als u nieuw bent in programmeren, begint u eerst met de Aan de slag-handleidingen.

Komt u uit een andere taal? Expressies in C# werken net zo veel als in Java, C++en JavaScript. Een verschil dat u moet noteren: operatoren voor samengestelde toewijzingen, zoals += en de operator incrementeel ++ zijn expressies in C#, zodat ze in grotere expressies kunnen worden weergegeven.

Een expressie is een stukje code dat de compiler evalueert om een waarde te produceren: een getal, een tekenreeks, een verwijzing of een bool. Is bijvoorbeeld 3 + 4 * 2 een expressie die het gehele getal 11evalueert en total > 10 een expressie is die resulteert in true of false.

De eenvoudigste expressies zijn letterlijke namen (zoals 42 of "hello") en variabelenamen (zoals total). U bouwt complexere expressies door eenvoudigere expressies te combineren met operators.

Expressies en uitspraken

Een expressie produceert een waarde. Een statement is een volledige instructie die door het programma wordt uitgevoerd. Veel statements bevatten expressies. Bijvoorbeeld is int total = 3 + 4 * 2; een variabeledeclaratie-instructie. De compiler evalueert de initialisatie-expressie 3 + 4 * 2, die die produceert 11en die waarde toewijst aan de nieuwe variabele total.

U kunt een expressie beschouwen als een woordgroep en een C#-instructie , zoals een volledige zin. Deze werkdefinities helpen u inzicht te krijgen in de formele terminologie en uitleg die u tegenkomt wanneer u meer leert over C#, hoewel bij gewone codering zelden vereist dat u het onderscheid bewust onthoudt.

Expressies combineren

Expressies kunnen worden gecombineerd. Overweeg 3 + 4 * 2. Deze enkele expressie bevat eigenlijk twee kleinere expressies: de vermenigvuldigingsexpressie4 * 2 en de optellingsexpressie3 + <result>. Wanneer expressies worden gecombineerd, heeft C# een regel nodig om te bepalen welke als eerste wordt geëvalueerd. Die regel is operatorprioriteit.

U hoeft de volledige prioriteitshiërarchie niet te onthouden. In de volgende sectie vindt u een overzicht van de dagelijkse groepen en haakjes, zodat u de volgorde altijd expliciet kunt maken wanneer u niet zeker weet.

Prioriteit van operator

Operatorprecedentie bepaalt hoe een gecombineerde expressie wordt gegroepeerd in subexpressies. Dit concept is vergelijkbaar met de volgorde van bewerkingsregels uit de wiskundeklasse. Een operator met een hogere prioriteit bindt nauwer aan de operanden. De expressie is gestructureerd alsof deze operanden tussen haakjes worden geplaatst. In 3 + 4 * 2, * heeft hogere prioriteit dan +, dus de expressiegroepen als 3 + (4 * 2), niet (3 + 4) * 2.

C# heeft meer prioriteitsgroepen dan de vier die hier worden samengevat. Deze extra groepen dwingen vertrouwde regels af — bijvoorbeeld vermenigvuldiging vóór optelling — en omvatten de volledige verzameling operatoren. In de volgende groepen wordt beschreven wat u het vaakst in dagelijkse code tegenkomt:

  1. Primaire, unaire en bereik : dit zijn drie afzonderlijke prioriteitsgroepen, die allemaal nauwer binden dan rekenkundig. Deze samenvatting combineert ze in één stap, omdat ze in de praktijk allemaal vóór rekenkundige bewerkingen van toepassing zijn.
    • Primaire operatoren — membertoegang (x.y), methodeaanroepen (f()), indexering (a[i]) en null-voorwaardelijke toegang (?., ?[]) — binden van allemaal het sterkst.
    • Unaire operatoren handelen op één operand: negatie (-x), logische NOT (!flag), voorvoegselverhoging (++i) en postfix increment (i++).
    • De bereikoperator (..) bouwt indexbereiken voor segmentexpressies, zoals array[1..4].
  2. Rekenkundige operatoren — *, /, % binden sterker dan + en -. Vermenigvuldigen en delen gebeuren vóór optellen en aftrekken.
  3. Vergelijking — <, >, <=, >=, !=, == binden minder sterk dan rekenkundige operatoren, dus rekenkundige bewerkingen worden uitgevoerd vóór de vergelijking.
  4. Logisch — && en || binden het minst sterk van de gebruikelijke operatoren, dus vergelijkingen worden eerst uitgevoerd voordat de logische combinatie plaatsvindt.

Deze prioriteit betekent dat de expressie score + bonus > threshold && attempts < maxAttempts precies wordt geëvalueerd zoals u het zou lezen: tel score en bonus bij elkaar op, vergelijk de som met threshold, vergelijk attempts met maxAttempts en combineer vervolgens de twee bool-resultaten met &&. Als u haakjes toevoegt om elke groepering expliciet te maken, wordt dezelfde structuur weergegeven: ((score + bonus) > threshold) && (attempts < maxAttempts).

Zie C#-operatoren en -expressies voor de volledige prioriteitshiërarchie voor elke operator.

Haakjes gebruiken om intentie duidelijk te maken

Haakjes overschrijven prioriteit en documenteren uw intentie tegelijkertijd. Wanneer de volgorde niet duidelijk is uit de bovenstaande groepen, voegt u haakjes toe:

int score = 80;
int bonus = 15;
int threshold = 90;
bool eligible = true;

// Without parentheses: || binds less tightly than &&, so this reads as:
//   eligible && (score + bonus > threshold) || bonus > 20
bool result1 = eligible && score + bonus > threshold || bonus > 20;

// With parentheses: forces the || to combine two complete conditions
bool result2 = (eligible && score + bonus > threshold) || bonus > 20;

Console.WriteLine(result1); // => True
Console.WriteLine(result2); // => True

// Parentheses can also change the result:
bool isAdmin = false;
bool isOwner = true;

// Without: && binds tighter, so: (isAdmin && isOwner) || true
bool access1 = isAdmin && isOwner || true;
// With: forces the || to run first
bool access2 = isAdmin && (isOwner || true);

Console.WriteLine(access1); // => True   (false && true is false; false || true is true)
Console.WriteLine(access2); // => False  (false && anything is false)

De laatste twee regels laten zien dat haakjes het resultaat kunnen wijzigen, niet alleen de stijl. Wanneer && en || samen worden weergegeven, voegt u haakjes toe om te bepalen welke voorwaarde het eerst wordt gecombineerd. Een lezer die (isAdmin && isOwner) || isSuperUser ziet, kent de bedoeling onmiddellijk.

Hoe expressies worden geëvalueerd

Begrijpen hoe C# gecombineerde expressies evalueert, is eenvoudiger met een analogie. Denk na over een complex rekenkundig probleem met potlood en papier: u identificeert de binnenste of hoogste prioriteitssubexpressie, berekent de tussentijdse waarde, noteren het resultaat en herhaalt u vervolgens met de volgende subexpressie, totdat u het uiteindelijke antwoord hebt bereikt.

C# volgt hetzelfde proces, geleid door twee regels:

Regel 1: Operanden evalueren van links naar rechts. Voor elke binaire expressie moeten beide operanden volledig worden geëvalueerd voordat de operator wordt toegepast. C# evalueert eerst de linkeroperand, vervolgens de rechter en voert vervolgens de bewerking uit.

Regel 2: Sommige operators kortsluiten. Bepaalde operators stoppen met evalueren zodra het resultaat is bepaald, waarbij alle resterende operanden worden overgeslagen:

  • && (voorwaardelijke EN): geeft false terug zodra de linkerzijde false is. De rechterkant wordt nooit geëvalueerd.
  • || (voorwaardelijk OF): geeft true terug zodra de linkerzijde true is. De rechterkant wordt nooit geëvalueerd.
  • ?: (voorwaardelijk/ternair): evalueert alleen de vertakking die overeenkomt met de voorwaarde. De andere vertakking wordt nooit geëvalueerd.
  • ?. (toegang tot null-voorwaardelijk lid) en ?[] (toegang tot null-voorwaardelijk element): stop en retourneer null onmiddellijk wanneer de linkerkant is null, waarbij de toegang of index van het lid wordt overgeslagen.
  • ??= (null-coalescing-toewijzing): wijst de rechterzijde alleen toe wanneer de linkerzijde null is.

Evaluatie van papier en potlood

Houd rekening met de expressie 3 + 6 / 2. Hoewel toevoeging als eerste in de leesvolgorde wordt weergegeven, / heeft deze hogere prioriteit dan +, dus 6 / 2 de subexpressie die het eerst evalueert. Doorloop het stapsgewijs, precies zoals u op papier zou doen:

3 + 6 / 2
      ↓   (evaluate 6 / 2 → 3)
3 +   3
  ↓   (evaluate 3 + 3 → 6)
  6

// 3 + 6 / 2
// Step 1: 6 / 2 has higher precedence → interim value 3
// Step 2: 3 + 3 → final result 6
int result = 3 + 6 / 2;
Console.WriteLine(result); // => 6

De tussentijdse waarde 3 die door 6 / 2 wordt geproduceerd, wordt de juiste operand van +, en het uiteindelijke resultaat is 6. Elke subexpressie produceert een tussentijdse waarde; deze tussentijdse waarden voeren de volgende subexpressie in, totdat slechts één waarde overblijft.

Associativiteit is een gerelateerd concept: wanneer twee operators dezelfde prioriteit hebben, bepaalt associativiteit welke het eerst gaat. De meeste C#-operators zijn links-associatief, wat betekent dat ze van links naar rechts groeperen. Dat a - b - c is hetzelfde als (a - b) - c, niet a - (b - c).

Evaluatie van kortsluiting in de praktijk

Evaluatie van kortsluiting is met name handig voor null-controles:

string? text = null;

// Safe: second condition runs only when text is not null
bool hasContent = text != null && text.Length > 0;
Console.WriteLine(hasContent); // => False  (short-circuits after null check; no NullReferenceException)

text = "hello";
hasContent = text != null && text.Length > 0;
Console.WriteLine(hasContent); // => True

// || short-circuits on true: right side is never evaluated when left side is true
string word = "hello";
bool anyMatch = word.StartsWith("h") || word.StartsWith("x");
Console.WriteLine(anyMatch); // => True  (right side never evaluated)

// ?. short-circuits on null: returns null without accessing .Length
string? maybeNull = null;
int? length = maybeNull?.Length;   // length is null; no NullReferenceException
Console.WriteLine(length.HasValue); // => False

text != null && text.Length > 0 is veilig omdat de tweede voorwaarde alleen wordt uitgevoerd als text dat niet nullzo is. Op dezelfde manier stopt ?. de evaluatie wanneer het een null-verwijzing tegenkomt, waardoor een NullReferenceException zonder expliciete if-controle wordt vermeden.

Zie C# null-operators voor een breder overzicht van null-veilige operators.

Zie ook

  • Last updated on