C#-operators

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? De meeste operators in dit artikel (+, -, , /*, &&%, , ||, !, !===<vergelijkingsoperatoren >en =) werken hetzelfde als in Java, C++en JavaScript. De belangrijkste verrassingen voor nieuwkomers zijn het gedrag van deling met gehele getallen, het onderscheid tussen prefix- en postfixnotatie voor ++/--, en de manier waarop samengestelde toewijzingen terug converteren naar het type aan de linkerkant.

Een operator combineert een of meer operanden in één waarde. U weet al over expressies en operatorprioriteit van C#-expressies; dit artikel gaat dieper in op de specifieke operators die u elke dag gaat gebruiken.

Rekenkundige operatoren

De vijf rekenkundige operatoren voeren numerieke berekeningen uit.

Operator Naam Voorbeeld Resultaat
+ Toevoeging 10 + 3 13
- Aftrekken 10 - 3 7
* Vermenigvuldiging 10 * 3 30
/ Divisie 10 / 3 3
% Rest 10 % 3 1 
int apples = 10;
int oranges = 3;

Console.WriteLine(apples + oranges);  // => 13  (addition)
Console.WriteLine(apples - oranges);  // => 7   (subtraction)
Console.WriteLine(apples * oranges);  // => 30  (multiplication)
Console.WriteLine(apples / oranges);  // => 3   (integer division: truncates toward zero)
Console.WriteLine(apples % oranges);  // => 1   (remainder)

// Integer division always truncates toward zero — the fractional part is discarded
int result = 7 / 2;
Console.WriteLine(result); // => 3, not 3.5

// Truncation applies to negative results too: -7 / 2 is -3, not -4
int negResult = -7 / 2;
Console.WriteLine(negResult); // => -3

// To get a decimal result, at least one operand must be a double or float
double precise = 7.0 / 2;
Console.WriteLine(precise); // => 3.5

// Remainder with negative operands: the sign of the result matches the dividend
Console.WriteLine(-7 % 3);  // => -1  (-7 = 3 × -2 + (-1))
Console.WriteLine(7 % -3);  // => 1   ( 7 = -3 × -2 + 1)

Deling met gehele getallen wordt afgerond naar nul. Wanneer beide operanden gehele getallen zijn, negeert / het fractionele deel: 7 / 2 is 3, niet 3.5. Afkappen gebeurt naar nul, niet naar het laagste getal: -7 / 2 is -3 (niet -4). Als u een decimaal resultaat wilt krijgen, moet ten minste één operand van een drijvendekommatype zijn: 7.0 / 2 is 3.5. Dit verschilt van sommige talen waarin / altijd een resultaat met drijvende komma oplevert.

Rest (%) geeft terug wat overblijft na een gehele deling: 10 % 3 is 1 omdat 10 = 3 × 3 + 1. Het is handig voor het doorlopen van een vast bereik (index % length), het testen van deelbaarheid (n % 2 == 0) en het extraheren van cijfers. Met negatieve operanden komt het teken van het resultaat overeen met het teken van het dividend (de linkeroperand): -7 % 3 is -1 en 7 % -3 is 1.

Unaire operators

Unaire operators handelen op één operand.

int temperature = 20;
int windChill = -5;

int heatIndex = +temperature;   // unary +: value unchanged (rarely needed)
int coldFactor = -windChill;    // unary -: negates the value → 5

Console.WriteLine(heatIndex);   // => 20
Console.WriteLine(coldFactor);  // => 5

bool isRaining = false;
bool isSunny = !isRaining;     // logical NOT: flips true/false
Console.WriteLine(isSunny);    // => True
  • +x (unaire plus) — laat de waarde ongewijzigd; zelden expliciet maar geldig geschreven.
  • -x (unaire min) — de waarde wordt genegeerd.
  • !x (logische NOT) — zet true om naar false en false naar true. U gebruikt ! vaak: if (!list.Contains(item)).

Verhogen en verlagen

++ voegt 1 toe en -- trekt 1 af. Beide hebben een voorvoegselformulier en een voorvoegselformulier die verschillen in welke waarde wordt geretourneerd:

int counter = 5;

// Prefix: increment first, then use the new value
int a = ++counter;
Console.WriteLine(a);       // => 6
Console.WriteLine(counter); // => 6

// Postfix: use the current value first, then increment
int b = counter++;
Console.WriteLine(b);       // => 6  (value before increment)
Console.WriteLine(counter); // => 7  (incremented after)

// Decrement works the same way
int score = 10;
Console.WriteLine(score--); // => 10 (current value; score becomes 9)
Console.WriteLine(score);   // => 9
  • Prefix (++i, --i): verhogen of verlagen de variabele eerst en retourneren vervolgens de nieuwe waarde.
  • Postfix (i++, i--): retourneert eerst de huidige waarde en vervolgens de variabele verhogen of verlagen.

Wanneer ++ of -- als een losse instructie voorkomt (niet als onderdeel van een grotere expressie), hebben prefix en postfix hetzelfde effect. Het onderscheid is alleen van belang wanneer het resultaat wordt gebruikt, bijvoorbeeld in een toewijzing of als methodeargument.

Relationele operators

Relationele operators vergelijken twee waarden en retourneren een bool.

Operator Meaning Voorbeeld
< Kleiner dan speed < limit
> Groter dan speed > limit
<= Kleiner dan of gelijk aan score <= 100
>= Groter dan of gelijk aan score >= 0 
int speed = 75;
int limit = 60;

Console.WriteLine(speed > limit);   // => True   (greater than)
Console.WriteLine(speed < limit);   // => False  (less than)
Console.WriteLine(speed >= limit);  // => True   (greater than or equal)
Console.WriteLine(speed <= limit);  // => False  (less than or equal)

// Relational operators work on all numeric types and char
// char comparison uses the character's numeric Unicode code point, not alphabetical position
// 'B' (U+0042, value 66) is less than 'A' (U+0041, value 65)? No — 'A' (65) < 'B' (66)
char grade = 'B';
Console.WriteLine(grade >= 'A' && grade <= 'C'); // => True  ('A'=65 <= 'B'=66 <= 'C'=67)

Vergelijkingsoperatoren werken op alle numerieke typen en char. Voor char wordt bij vergelijkingen de numerieke waarde van het Unicode-codepunt van het teken gebruikt, niet een alfabetische of domeinspecifieke volgorde. In het bovenstaande voorbeeld met cijfers is 'B' groter dan of gelijk aan 'A' omdat 'B' de Unicode-waarde 66 heeft en 'A' de Unicode-waarde 65 heeft — de getallen bepalen de vergelijking, niet de betekenis van de letterbeoordelingen.

Gelijkheidsoperators

== en != controleer of twee waarden gelijk zijn of niet. != is true wanneer de operanden niet gelijk zijn, en false wanneer ze dat wel zijn.

int expected = 42;
int actual = 42;

Console.WriteLine(actual == expected);  // => True   (values are equal)
Console.WriteLine(actual != expected);  // => False  (true when values are not equal)

string name = "Alice";
Console.WriteLine(name == "Alice");  // => True   (string content matches)
Console.WriteLine(name == "alice");  // => False  (case-sensitive)

int x = 5;
Console.WriteLine(x == 10);  // => False

Voor numerieke typen en string, worden de waarden getest door gelijkheid. Voor referentietypen is de standaardidentiteit (of twee variabelen verwijzen naar hetzelfde object), maar veel typen, waaronder string en record overschrijven dit om inhoud te vergelijken. Zie Gelijkheidsvergelijkingen voor het volledige beeld: hoe gelijkheid werkt voor waardetypen, referentietypen, records en structs.

Note

C# heeft geen === operator. Het schrijven van === is een compile-timefout:

// This does not compile — C# has no === operator
bool same = (x === 10);

Als u uit JavaScript komt, gebruik dan == voor vergelijking op waarde (C# == vergelijkt al op waarde voor primitieve typen en tekenreeksen). Een veelvoorkomende gerelateerde fout is het per ongeluk schrijven = (toewijzing) waarbij u bedoelde == (gelijkheidscontrole). De compiler detecteert de meest voorkomende vormen, maar controleer elke if-voorwaarde die = bevat nog eens.

Conditioneel-logische operatoren

&& (AND) en || (OR) combineren bool-expressies.

int age = 20;
bool hasTicket = true;

// && (AND): both sides must be true
bool canEnter = age >= 18 && hasTicket;
Console.WriteLine(canEnter); // => True

// || (OR): at least one side must be true
bool freeEntry = age < 5 || age >= 65;
Console.WriteLine(freeEntry); // => False

// Short-circuit: right side is skipped when the result is already determined
// Here, items.Count is never called if items is null
List<string>? items = null;
bool hasItems = items != null && items.Count > 0;
Console.WriteLine(hasItems); // => False  (short-circuits; no NullReferenceException)

Beide operatoren hebben kortsluitgedrag: ze slaan de evaluatie van de rechteroperand over wanneer het resultaat al vaststaat.

  • && geeft false terug zodra de linkerkant false is. De rechterkant wordt nooit geëvalueerd.
  • || retourneert true zodra de linkerkant true is. De rechterkant wordt nooit geëvalueerd.

Kortsluitingsgedrag heeft een praktisch voordeel: u kunt een bewerking aan de rechterkant veilig bewaken met een null-controle aan de linkerkant, zoals in het bovenstaande voorbeeld wordt weergegeven. Als items gelijk is aan null, stopt de && daar — items.Count wordt nooit aangeroepen, dus er wordt geen NullReferenceException opgeworpen.

Voorwaardelijke operator ?:

De voorwaardelijke operator (ook wel de ternaire operator genoemd) evalueert een van de twee expressies op basis van een voorwaarde:

condition ? value-when-true : value-when-false

int temperature2 = 35;

// condition ? value-when-true : value-when-false
string weather = temperature2 > 30 ? "hot" : "comfortable";
Console.WriteLine(weather); // => hot

// Only the matching branch evaluates — the other branch is never run
int divisor = 0;
// The division 10 / divisor is never evaluated because divisor == 0 is true
int safe = divisor == 0 ? -1 : 10 / divisor;
Console.WriteLine(safe); // => -1

De operator evalueert altijd precies één vertakking. De ?: zijde die niet overeenkomt met de voorwaarde wordt nooit geëvalueerd. Dit maakt het veilig om aan één kant een expressie te gebruiken die bij andere invoerwaarden fout zou gaan, mits de voorwaarde die correct afschermt.

Gebruik ?: voor eenvoudige inlinekeuzes. Voor voorwaarden in meerdere richtingen of codeblokken is een if/else instructie meestal duidelijker.

Toewijzingsoperatoren

Met de eenvoudige toewijzingsoperator = wordt een waarde opgeslagen in een variabele:

int level = 1;  // declaration + initialization
level = 5;      // reassignment

Toewijzing in C# is rechts-associatief, wat betekent dat a = b = c = 0 van rechts naar links wordt geëvalueerd: c krijgt 0, vervolgens krijgt b0, en daarna krijgt a0.

Samengestelde toewijzing

Samengestelde toewijzingsoperatoren combineren een binaire bewerking met toewijzing:

Operator Gelijk aan
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y 
int level = 1;
level = 5;          // simple assignment: replaces the value
Console.WriteLine(level); // => 5

// Compound assignment: short form of binary operation + assignment
int hp = 100;
hp += 20;   // same as: hp = hp + 20
Console.WriteLine(hp); // => 120
hp -= 10;   // same as: hp = hp - 10
Console.WriteLine(hp); // => 110
hp *= 2;    // same as: hp = hp * 2
Console.WriteLine(hp); // => 220
hp /= 3;    // same as: hp = hp / 3 (integer division)
Console.WriteLine(hp); // => 73
hp %= 7;    // same as: hp = hp % 7
Console.WriteLine(hp); // => 3

Samengestelde toewijzing is meer dan alleen maar een verkorte notatie. Het evalueert de linkerkant precies één keer en converteert vervolgens het resultaat terug naar het type linkerkant. Dit is belangrijk wanneer de linkerkant bijwerkingen heeft (zoals array-indexering), en daarom compileert een samengestelde toewijzing aan een byte-variabele zonder een expliciete cast, terwijl de uitgeschreven vorm dat niet doet:

// Assignment is right-associative: evaluated right to left
int a2, b2, c2;
a2 = b2 = c2 = 0;     // c2 = 0 first, then b2 = 0, then a2 = 0
Console.WriteLine($"{a2} {b2} {c2}"); // => 0 0 0

// Compound assignment evaluates the left side once and converts back to the LHS type
byte small = 200;
small += 10;  // equivalent to: small = (byte)(small + 10); result is 210
Console.WriteLine(small); // => 210

small += 10 compileert omdat de compiler de vermalingsconversie automatisch invoegt: het resultaat, 210past binnen het byte bereik van 0-255. small = small + 10 vereist een expliciete (byte)-typeconversie, omdat de rekenkundige bewerking beide operanden promoveert naar int.

Andere C#-operators

Dit artikel bevat informatie over de operators die u het meest in dagelijkse code tegenkomt. De C#-taal bevat meer operators die nuttig zijn in specifieke scenario's:

  • Shift-operatoren (<<, >>, >>>) - de bits van een geheel getal naar links of rechts verplaatsen door een opgegeven aantal posities. Bitsgewijze en logische operatoren voor gehele getallen (&, |, ^, ~) — combineren of inverteren waarden van gehele getallen bit voor bit, nuttig in flags, maskers en low-level code: Bitsgewijze operatoren en shift-operatoren
  • checked en unchecked — bepalen of een overloop van gehele getallen een uitzondering (checked) genereert of op de achtergrond terugloopt (unchecked): Ingeschakeld en uitgeschakeld
  • Null-operatoren (??, ??=, ?., ?[]) — null-waarden veilig verwerken door standaardwaarden te bieden of ledentoegang kort te sluiten: Null-operatoren
  • Operatoren voor typetests en conversie (is, as, cast(T)typeof) - het runtimetype van een waarde controleren of converteren: Typetests en cast-operators
  • Bereik- en indexoperators (.., ^) - bereiken en eind-relatieve indexen maken voor segmentmatrices en spans: Toegang tot leden en null-voorwaardelijke operators
  • Deconstructietoewijzing — een tuple of type uitpakken naar afzonderlijke variabelen in één expressie: Tuples en andere typen deconstrueren

Zie ook

  • Last updated on