12 Uitdrukkingen

12.1 Algemeen

Een expressie is een reeks operatoren en operanden. Met deze component worden de syntaxis, volgorde van evaluatie van operanden en operatoren en de betekenis van expressies gedefinieerd.

12.2 Uitdrukkingclassificaties

12.2.1 Algemeen

Het resultaat van een expressie wordt geclassificeerd als een van de volgende:

• Een waarde. Elke waarde heeft een gekoppeld type.
• Een variabele. Tenzij anders opgegeven, wordt een variabele expliciet getypt en heeft een gekoppeld type, namelijk het gedeclareerde type van de variabele. Een impliciet getypte variabele heeft geen gekoppeld type.
• Een letterlijke waarde van null. Een expressie met deze classificatie kan impliciet worden geconverteerd naar een verwijzingstype of null-waardetype.
• Een anonieme functie. Een expressie met deze classificatie kan impliciet worden geconverteerd naar een compatibel type delegeaat of expressieboomtype.
• Een tuple. Elke tuple heeft een vast aantal elementen, elk met een expressie en een optionele tuple-elementnaam.
• Toegang tot een eigendom. Elke eigenschapstoegang heeft een bijbehorend type, namelijk het type van de eigenschap. Bovendien kan een eigenschapstoegang een bijbehorende instantie-expressie hebben. Wanneer een accessor van een exemplaareigenschapstoegang wordt aangeroepen, wordt het resultaat van het evalueren van de exemplaarexpressie het exemplaar dat wordt vertegenwoordigd door this (§12.8.14).
• Toegang tot een indexeerfunctie. Elke indexeerfunctietoegang heeft een gekoppeld type, namelijk het elementtype van de indexeerfunctie. Bovendien heeft een indexeerfunctietoegang een bijbehorende exemplaarexpressie en een bijbehorende argumentenlijst. Wanneer een toegangsfunctie van een indexeerfunctie wordt aangeroepen, wordt het resultaat van het evalueren van de exemplaarexpressie het exemplaar dat wordt vertegenwoordigd door this (§12.8.14) en wordt het resultaat van het evalueren van de argumentenlijst de parameterlijst van de aanroep.
• Niets. Dit gebeurt wanneer de expressie een aanroep van een methode is met een retourtype van void. Een expressie die als niets wordt geclassificeerd, is alleen geldig in de context van een statement_expression (§13.7) of als de hoofdtekst van een lambda_expression (§12.21).

Voor expressies die optreden als subexpressies van grotere expressies, met de genoteerde beperkingen, kan het resultaat ook worden geclassificeerd als een van de volgende:

• Een naamruimte. Een expressie met deze classificatie kan alleen worden weergegeven als de linkerkant van een member_access (§12.8.7). In een andere context veroorzaakt een expressie die is geclassificeerd als een naamruimte een compileertijdfout.
• Een type. Een expressie met deze classificatie kan alleen worden weergegeven als de linkerkant van een member_access (§12.8.7). In een andere context veroorzaakt een expressie die is geclassificeerd als een type een compileertijdfout.
• Een methodegroep, een set overbelaste methoden die het gevolg zijn van een ledenopzoekactie (§12.5). Een methodegroep kan een bijbehorende exemplaarexpressie en een lijst met bijbehorende typeargumenten hebben. Wanneer een exemplaarmethode wordt aangeroepen, wordt het resultaat van het evalueren van de exemplaarexpressie het exemplaar dat wordt vertegenwoordigd door this (§12.8.14). Een methodegroep is toegestaan in een invocation_expression (§12.8.10) of een delegate_creation_expression (§12.8.17.5), en kan impliciet worden geconverteerd naar een compatibel gemachtigdetype (§10,8). In een andere context veroorzaakt een expressie die is geclassificeerd als een methodegroep een compilatiefout.
• Toegang tot een evenement Elke gebeurtenistoegang heeft een gekoppeld type, namelijk het type gebeurtenis. Bovendien kan een gebeurtenistoegang een bijbehorende exemplaarexpressie hebben. Een gebeurtenistoegang kan worden weergegeven als de linkeroperand van de += en -= operators (§12.23.5). In een andere context veroorzaakt een expressie die is geclassificeerd als gebeurtenistoegang een compilatiefout. Wanneer een accessor van een exemplaargebeurtenistoegang wordt aangeroepen, wordt het resultaat van het evalueren van de exemplaarexpressie het exemplaar dat wordt vertegenwoordigd door this (§12.8.14).
• Een throw-expressie, die in verschillende contexten kan worden gebruikt om een uitzondering in een expressie te genereren. Een throw-expressie kan worden geconverteerd door een impliciete conversie naar elk type.

Een toegang tot eigenschappen of indexertoegang wordt altijd opnieuw geclassificeerd als een waarde door de get-accessor of set-accessor aan te roepen. De specifieke toegangsfunctie wordt bepaald door de context van de toegang tot de eigenschap of indexeerfunctie: Als de toegang het doel van een toewijzing is, wordt de settoegangsfunctie aangeroepen om een nieuwe waarde toe te wijzen (§12.23.2). Anders wordt de get accessor aangeroepen om de huidige waarde te verkrijgen (§12.2.2).

Een exemplaartoegangsfunctie is een eigenschapstoegang voor een exemplaar, een gebeurtenistoegang op een exemplaar of een indexeerfunctietoegang.

12.2.2 Waarden van expressies

De meeste constructies die betrekking hebben op een expressie, vereisen uiteindelijk dat de expressie een waarde aangeeft. Als de werkelijke expressie in dergelijke gevallen een naamruimte, een type, een methodegroep of niets aangeeft, treedt er een compilatietijdfout op. Als de expressie echter een eigenschapstoegang, een indexeerfunctietoegang of een variabele aangeeft, wordt de waarde van de eigenschap, indexeerfunctie of variabele impliciet vervangen:

• De waarde van een variabele is gewoon de waarde die momenteel is opgeslagen in de opslaglocatie die wordt geïdentificeerd door de variabele. Een variabele wordt beschouwd als definitief toegewezen (§9.4) voordat de waarde ervan kan worden verkregen, of anders treedt er een compilatiefout op.
• De waarde van een eigenschapstoegangsexpressie wordt verkregen door de get accessor van de eigenschap aan te roepen. Als de eigenschap geen get-accessor heeft, ontstaat er een compilatiefout. Anders wordt een aanroep van een functielid (§12.6.6) uitgevoerd en wordt het resultaat van de aanroep de waarde van de expressie voor eigenschapstoegang.
• De waarde van een indexeerfunctie-toegangsexpressie wordt verkregen door de get-accessor van de indexeerfunctie aan te roepen. Als de indexer geen gettoegangsmethode heeft, ontstaat er een fout tijdens de compilatie. Anders wordt een functielid aanroep (§12.6.6) uitgevoerd met de argumentenlijst die is gekoppeld aan de toegangsexpressie van de indexeerfunctie en wordt het resultaat van de aanroep de waarde van de toegangsexpressie van de indexeerfunctie.
• De waarde van een tuple-expressie wordt verkregen door een impliciete tupleconversie (§10.2.13) toe te passen op het type tuple-expressie. Het is een fout om de waarde van een tuple-expressie te achterhalen die geen type heeft.

12.3 Statische en dynamische binding

12.3.1 Algemeen

Binding is het proces van het bepalen waarnaar een bewerking verwijst, op basis van het type of de waarde van expressies (argumenten, operanden, ontvangers). De binding van een methode-aanroep wordt bijvoorbeeld bepaald op basis van het type ontvanger en argumenten. De binding van een operator wordt bepaald op basis van het type operanden.

In C# wordt de binding van een bewerking meestal bepaald tijdens het compileren, op basis van het compileertijdtype van de subexpressies. Als een expressie een fout bevat, wordt de fout ook gedetecteerd en gerapporteerd tijdens het compileren. Deze methode wordt statische bindinggenoemd.

Als een expressie echter een dynamische expressie is (d.w.z. heeft het type dynamic) geeft dit aan dat elke binding waaraan deze deelneemt, moet zijn gebaseerd op het runtimetype in plaats van het type dat het tijdens het compileren heeft. De binding van een dergelijke bewerking wordt daarom uitgesteld tot de tijd waarop de bewerking moet worden uitgevoerd tijdens het uitvoeren van het programma. Dit wordt dynamische bindinggenoemd.

Wanneer een bewerking dynamisch is gebonden, wordt tijdens het compileren weinig of geen controle uitgevoerd. In plaats daarvan, als de uitvoeringstijdbinding mislukt, worden fouten tijdens de uitvoeringstijd als uitzonderingen gerapporteerd.

De volgende bewerkingen in C# zijn onderhevig aan binding:

• Toegang tot leden: e.M
• Aanroep van methode: e.M(e₁,...,eᵥ)
• Aanroep delegeren: e(e₁,...,eᵥ)
• Toegang tot elementen: e[e₁,...,eᵥ]
• Object maken: nieuwe C(e₁,...,eᵥ)
• Overbelaste unaire operatoren: +, -, ! (alleen logische negatie), ~, ++, --, true, false
• Overbelaste binaire operatoren: +, -, *, /, %, &, &&, |, ||, ??, ^, <<, >>, ==, !=, >, <, >=, <=
• Toewijzingsoperatoren: =, = ref, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=, ??=
• Impliciete en expliciete conversies

Wanneer er geen dynamische expressies betrokken zijn, wordt in C# standaard ingesteld op statische binding, wat betekent dat de compileertijdtypen van subexpressies worden gebruikt in het selectieproces. Wanneer een van de subexpressies in de bovenstaande bewerkingen echter een dynamische expressie is, is de bewerking in plaats daarvan dynamisch gebonden.

Het is een compilatietijdfout als een methode-aanroep dynamisch is gebonden en een van de parameters, inclusief de ontvanger, invoerparameters zijn.

12.3.2 Bindingstijd

Statische binding vindt plaats tijdens het compileren, terwijl dynamische binding plaatsvindt tijdens runtime. In de volgende subclauses verwijst de term binding-time verwijst naar compileertijd of runtime, afhankelijk van wanneer de binding plaatsvindt.

Voorbeeld van: Hieronder ziet u de noties van statische en dynamische binding en bindingstijd:

object o = 5;
dynamic d = 5;
Console.WriteLine(5); // static binding to Console.WriteLine(int)
Console.WriteLine(o); // static binding to Console.WriteLine(object)
Console.WriteLine(d); // dynamic binding to Console.WriteLine(int)

De eerste twee aanroepen zijn statisch gebonden: de overbelasting van Console.WriteLine wordt gekozen op basis van het type compileertijd van hun argument. De bindingstijd wordt dus compilatietijd.

De derde aanroep is dynamisch gebonden: de overbelasting van Console.WriteLine wordt gekozen op basis van het runtimetype van het argument. Dit gebeurt omdat het argument een dynamische expressie is: het type compileertijd is dynamisch. De bindingstijd voor de derde aanroep is dus uitvoeringstijd.

einde voorbeeld

12.3.3 Dynamische binding

Deze subclause is informatief.

Met dynamische binding kunnen C#-programma's communiceren met dynamische objecten, d.w.: objecten die niet voldoen aan de normale regels van het C#-typesysteem. Dynamische objecten kunnen objecten zijn uit andere programmeertalen met verschillende typen systemen, of ze kunnen objecten zijn die programmatisch zijn ingesteld om hun eigen bindingsemantiek voor verschillende bewerkingen te implementeren.

Het mechanisme waarmee een dynamisch object zijn eigen semantiek implementeert, is door de implementatie gedefinieerd. Een bepaalde interface, opnieuw door implementatie gedefinieerd, wordt geïmplementeerd door dynamische objecten om de C#-runtime te signaleren dat ze speciale semantiek hebben. Wanneer bewerkingen op een dynamisch object dus dynamisch zijn gebonden, nemen ze hun eigen bindingsemantiek over, in plaats van C# zoals opgegeven in deze specificatie.

Hoewel het doel van dynamische binding is om interoperation met dynamische objecten mogelijk te maken, staat C# dynamische binding toe op alle objecten, ongeacht of ze dynamisch zijn of niet. Dit maakt een soepelere integratie van dynamische objecten mogelijk, omdat de resultaten van bewerkingen hierop niet altijd dynamische objecten zijn, maar nog steeds van een type onbekend zijn voor de programmeur tijdens het compileren. Dynamische binding kan ook helpen bij het elimineren van foutgevoelige op reflectie gebaseerde code, zelfs wanneer de betrokken objecten geen dynamische objecten zijn.

12.3.4 Typen subexpressies

Wanneer een bewerking statisch is gebonden, wordt het type subexpressie (bijvoorbeeld een ontvanger en argument, een index of een operand) altijd beschouwd als het type compileertijd van die expressie.

Wanneer een bewerking dynamisch is gebonden, wordt het type subexpressie op verschillende manieren bepaald, afhankelijk van het type compileertijd van de subexpressie:

• Een subexpressie van compile-time type dynamisch wordt geacht het type te hebben van de werkelijke waarde waarnaar de expressie tijdens de uitvoertijd evalueert.
• Een subexpressie waarvan het compileertijdtype een typeparameter is, wordt beschouwd als het type waaraan de typeparameter bij uitvoering is gebonden.
• Anders wordt de subexpressie geacht zijn compileertijd-type te hebben.

12.4 Operatoren

12.4.1 Algemeen

Expressies worden samengesteld op basis van operanden en operators. De operatoren van een expressie geven aan welke bewerkingen moeten worden toegepast op de operanden.

voorbeeld: voorbeelden van operators zijn onder andere +, -, *, /en new. Voorbeelden van operanden zijn letterlijke waarden, velden, lokale variabelen en expressies. einde voorbeeld

Er zijn drie soorten operators:

• Unaire operatoren. De unaire operatoren nemen één operand en gebruiken een voorvoegsel notatie (zoals –x) of achtervoegsel notatie (zoals x++).
• Binaire operatoren. De binaire operatoren nemen twee operanden en gebruiken allemaal infix-notatie (zoals x + y).
• Ternaire operator. Slechts één ternaire operator, ?:, bestaat; het duurt drie operanden en maakt gebruik van infix notatie (c ? x : y).

De beoordelingsvolgorde van operators in een expressie wordt bepaald door de prioriteit en associatieve van de operatoren (§12.4.2).

Operanden in een expressie worden van links naar rechts geëvalueerd.

voorbeeld: in F(i) + G(i++) * H(i)wordt de methode F aangeroepen met behulp van de oude waarde van i, wordt de methode G aangeroepen met de oude waarde van ien tot slot wordt de methode H aangeroepen met de nieuwe waarde i. Dit is gescheiden van en niet gerelateerd aan de prioriteit van de operator. einde voorbeeld

Bepaalde operators kunnen worden overbelast. Bij overbelasting van operatoren (§12.4.3) kunnen door de gebruiker gedefinieerde operator-implementaties worden opgegeven voor bewerkingen waarbij een of beide operanden van een door de gebruiker gedefinieerde klasse of struct-type zijn.

12.4.2 Operatorprioriteit en associativiteit

Wanneer een expressie meerdere operators bevat, bepaalt de prioriteit van de operators de volgorde waarin de afzonderlijke operators worden geëvalueerd.

Opmerking: de expressie x + y * z wordt bijvoorbeeld geëvalueerd als x + (y * z) omdat de operator * een hogere prioriteit heeft dan de operator binaire +. eindnotitie

De prioriteit van een operator wordt bepaald door de definitie van de bijbehorende grammaticaproductie.

Opmerking: een additive_expression bestaat bijvoorbeeld uit een reeks multiplicative_expressiongescheiden door +- of - operatoren, waardoor de operatoren + en - lagere prioriteit hebben dan de operatoren *, /en %. eindnotitie

Opmerking: de volgende tabel bevat een overzicht van alle operatoren in volgorde van prioriteit van hoog naar laag:

subclausule	categorie	Operatoren
§12.8	Primair	x.y x?.y f(x) a[x] a?[x] x++ x-- x! new typeof default checked unchecked delegate stackalloc
§12.9	Unaire	+ - ! ~ ^ ++x --x (T)x await x
§12.10	Bereik	..
§12.11	Schakelaar	switch { … }
§12.12	Multiplicatieve	* / %
§12.12	Toevoeging	+ -
§12.13	Verschuiving	<< >>
§12.14	Relationele en type-testen	< > <= >= is as
§12.14	Gelijkheid	== !=
§12.15	Logische AND	&
§12.15	Logische XOR	^
§12.15	Logische OR	\|
§12.16	Voorwaardelijk en	&&
§12.16	Voorwaardelijk OF	\|\|
§12.17 en §12.18	Null-coalescing en gooi-expressie	?? throw x
§12.20	Voorwaardelijk	?:
§12.23 en §12.21	Toewijzing en lambda-expressie	= = ref *= /= %= += -= <<= >>= &= ^= \|= => ??=

eindnotitie

Wanneer een operand plaatsvindt tussen twee operators met dezelfde prioriteit, bepaalt de associativiteit van de operators de volgorde waarin de bewerkingen worden uitgevoerd:

• Met uitzondering van de toewijzingsoperatoren, de bereikoperator en de operator null-samensamenvulling, zijn alle binaire operatoren links-associatief, wat betekent dat bewerkingen van links naar rechts worden uitgevoerd.

  voorbeeld van: x + y + z wordt geëvalueerd als (x + y) + z. einde voorbeeld

• De toewijzingsoperatoren, de null-coalescerende operator en de voorwaardelijke operator (?:) zijn rechts-associatieve, wat betekent dat bewerkingen van rechts naar links worden uitgevoerd.

  voorbeeld van: x = y = z wordt geëvalueerd als x = (y = z). einde voorbeeld

• De bereikoperator is niet-associatief, wat betekent dat de linker- of rechteroperand van een bereikoperator geen range_expression kan zijn.

  Voorbeeld: Beide x..y..z en x..(y..z) zijn ongeldig, net als .. niet-associatief. einde voorbeeld

Prioriteit en associativiteit kunnen worden beheerd met haakjes.

voorbeeld: x + y * z vermenigvuldigt eerst y met z en voegt vervolgens het resultaat toe aan x, maar (x + y) * z voegt eerst x en y toe en vermenigvuldigt vervolgens het resultaat met z. einde voorbeeld

12.4.3 Operator-overbelasting

Alle unaire en binaire operators hebben vooraf gedefinieerde implementaties. Daarnaast kunnen door de gebruiker gedefinieerde implementaties worden ingevoerd door operatordeclaraties (§15.10) in klassen en structs op te geven. Door de gebruiker gedefinieerde operator-implementaties hebben altijd voorrang op vooraf gedefinieerde operator-implementaties: Alleen wanneer er geen toepasselijke door de gebruiker gedefinieerde operator-implementaties bestaan, worden de vooraf gedefinieerde implementaties van operatoren beschouwd, zoals beschreven in §12.4.4 en §12.4.5.

De overbelaste unaire operatorenzijn:

+ - ! (alleen logische ontkenning) ~ ++ -- true false

Alleen de hierboven genoemde operators kunnen overbelast worden. Het is met name niet mogelijk om de operator null-vergeefs te overbelasten (postfix, !) of de unaire index van de eindoperator (voorvoegsel ^, §12.9.6)).

Opmerking: Hoewel true en false niet expliciet worden gebruikt in expressies (en daarom niet zijn opgenomen in de prioriteitstabel in §12.4.2), worden ze beschouwd als operators omdat ze worden aangeroepen in verschillende expressiecontexten: Boole-expressies (§12.26) en expressies met betrekking tot de voorwaardelijke operatoren (§12.20) en voorwaardelijke logische operators (§12.16). eindnotitie

De overbelastingsbare binaire operatorenzijn:

+ - * / % & | ^ << >> == != > < <= >=

Alleen de hierboven genoemde operators kunnen overbelast worden. In het bijzonder is het niet mogelijk om de toegang van leden, methode-aanroepen of de .., =, &&||???:=>checkedunchecked, new, , typeof, , , defaulten asis operators te overbelasten.

Wanneer een binaire operator overbelast is, wordt de bijbehorende samengestelde toewijzingsoperator, indien aanwezig, ook impliciet overbelast.

Voorbeeld: een overbelasting van operatoren * is ook een overbelasting van operatoren *=. Dit wordt verder beschreven in §12.23. einde voorbeeld

De toewijzingsoperator zelf (=) kan niet worden overbelast. Een toewijzing voert altijd een eenvoudig archief van een waarde uit in een variabele (§12.23.2).

Cast-bewerkingen, zoals (T)x, worden overbelast door door de gebruiker gedefinieerde conversies (§10,5).

Opmerking: door de gebruiker gedefinieerde conversies hebben geen invloed op het gedrag van de operators voor is of as. eindnotitie

Toegang tot elementen, zoals a[x], wordt niet beschouwd als een overloadbare operator. In plaats daarvan wordt door de gebruiker gedefinieerde indexering ondersteund via indexeerfuncties (§15,9).

In expressies wordt naar operators verwezen met behulp van operator-notatie en in declaraties wordt naar operators verwezen met behulp van functionele notatie. In de volgende tabel ziet u de relatie tussen operator- en functionele notaties voor unaire en binaire operatoren. In het eerste item geeft «op» een overbelastingsbare unary-voorvoegseloperator aan. In de tweede vermelding geeft «op» de unary postfix ++ en -- operators aan. In de derde vermelding geeft «op» elke overbelastingsbare binaire operator aan.

Opmerking: Voor een voorbeeld van het overbelasten van de operatoren ++ en --, zie §15.10.2. eindnotitie

Door de gebruiker gedefinieerde operatordeclaraties vereisen altijd ten minste één van de parameters van het klasse- of structtype dat de operatordeclaratie bevat.

Opmerking: het is dus niet mogelijk dat een door de gebruiker gedefinieerde operator dezelfde handtekening heeft als een vooraf gedefinieerde operator. eindnotitie

Door de gebruiker gedefinieerde operatordeclaraties kunnen de syntaxis, prioriteit of associativiteit van een operator niet wijzigen.

voorbeeld: de operator / is altijd een binaire operator, heeft altijd het prioriteitsniveau dat is opgegeven in §12.4.2en is altijd links-associatief. einde voorbeeld

Opmerking: hoewel het mogelijk is voor een door de gebruiker gedefinieerde operator om berekeningen uit te voeren, worden implementaties die andere resultaten opleveren dan de implementaties die intuïtief worden verwacht sterk afgeraden. Een implementatie van operator == moet bijvoorbeeld de twee operanden voor gelijkheid vergelijken en een geschikt bool resultaat retourneren. eindnotitie

De beschrijvingen van individuele operators in §12.9 tot en met §12.23 geven de vooraf gedefinieerde implementaties van de operators en eventuele aanvullende regels op die van toepassing zijn op elke operator. De beschrijvingen maken gebruik van de termen unaire operator overbelastingsresolutie, binaire operator overbelastingsresolutie, numerieke promotieen definities van opgeheven operatoren die in de volgende subclauses worden gevonden.

12.4.4 Oplossing voor unaire operatoroverbelasting

Een werking van het formulier «op» x of x «op», waarbij «op» een overbelaste unaire operator is en x een expressie van het type Xis, wordt als volgt verwerkt:

• De set door de gebruiker gedefinieerde kandidaatoperators die door X worden verstrekt voor de bewerking operator «op»(x) wordt bepaald aan de hand van de regels van §12.4.6.
• Als de set door de gebruiker gedefinieerde kandidaatoperators niet leeg is, wordt dit de set kandidaatoperators voor de bewerking. Anders vormen de vooraf gedefinieerde binaire operator «op»-implementaties, inclusief hun aangepaste vormen, de verzameling kandidaatoperatoren voor de bewerking. De vooraf gedefinieerde implementaties van een bepaalde operator worden opgegeven in de beschrijving van de operator. De vooraf gedefinieerde operators die worden geleverd door een enum- of delegatetype, worden alleen opgenomen in deze set wanneer het bindingstijdtype (of het onderliggende type als het een nullable type is) van een operand het enum- of delegatetype is.
• De regels voor overbelastingsoplossing van §12.6.4 worden toegepast op de set kandidaatoperatoren om de beste operator te selecteren met betrekking tot de lijst met argumenten (x), en deze operator wordt het resultaat van het overbelastingsoplossingsproces. Als overbelastingsresolutie niet één beste operator selecteert, treedt er een bindingstijdfout op.

12.4.5 Overbelasting van binaire operatoren

Een werking van het formulier x «op» y, waarbij «op» een overbelastingbare binaire operator is, x een expressie van het type Xis en y een expressie van het type Yis, wordt als volgt verwerkt:

• De set door de gebruiker gedefinieerde kandidaatoperators die worden geleverd door X en Y voor de bewerking operator «op»(x, y) wordt bepaald. De set bestaat uit de vereniging van de door X en Yverstrekte kandidaat-operators, die elk worden bepaald volgens de regels van §12.4.6. Voor de gecombineerde set worden kandidaten als volgt samengevoegd:
  • Als X en Y identiteit converteerbaar zijn of als X en Y zijn afgeleid van een gemeenschappelijk basistype, worden gedeelde kandidaatoperators slechts eenmaal in de gecombineerde set uitgevoerd.
  • Als er een identiteitsconversie is tussen X en Y, heeft een operator «op»Y van Y hetzelfde retourtype als een «op»X geleverd door X en de operandtypen van «op»Y een identiteitsconversie hebben naar de bijbehorende operandtypen van «op»X dan vindt er slechts «op»X plaats in de set.
• Als de set door de gebruiker gedefinieerde kandidaatoperators niet leeg is, wordt dit de set kandidaatoperators voor de bewerking. Anders vormen de vooraf gedefinieerde binaire operator «op»-implementaties, inclusief hun aangepaste vormen, de verzameling kandidaatoperatoren voor de bewerking. De vooraf gedefinieerde implementaties van een bepaalde operator worden opgegeven in de beschrijving van de operator. Voor voorgedefinieerde enum- en delegate-operatoren zijn de enige operators die worden beschouwd die door een enum- of delegatetype worden geleverd dat het bindingstijdtype van een van de operanden is.
• De regels voor overbelastingsoplossing van §12.6.4 worden toegepast op de set kandidaatoperatoren om de beste operator te selecteren met betrekking tot de lijst met argumenten (x, y), en deze operator wordt het resultaat van het overbelastingsoplossingsproces. Als overbelastingsresolutie niet één beste operator selecteert, treedt er een bindingstijdfout op.

12.4.6 Door de gebruiker gedefinieerde kandidaatoperators

Gezien een type T en een bewerking operator «op»(A), waarbij «op» een overbelastingsbare operator is en A een lijst met argumenten is, wordt de set door de gebruiker gedefinieerde kandidaatoperators die door T worden verstrekt voor operator-«op»(A) als volgt bepaald:

• Het type T₀bepalen. Als T een nullable waarde type is, dan is T₀ het onderliggende type; anders is T₀ gelijk aan T.
• Voor alle operator «op» declaraties in T₀ en alle opgeheven vormen van dergelijke exploitanten, indien ten minste één exploitant van toepassing is (§12.6.4.2) met betrekking tot de lijst met argumenten A, bestaat de set kandidaat-exploitanten uit alle toepasselijke exploitanten in T₀.
• Als T₀ anders objectis, is de set van kandidaat-operators leeg.
• Anders is de set kandidaat-operators die worden geleverd door T₀ de set kandidaat-operators die worden geleverd door de directe basisklasse van T₀, of de effectieve basisklasse van T₀ als T₀ een typeparameter is.

12.4.7 Numerieke promoties

12.4.7.1 Algemeen

Deze subclause is informatief.

§12.4.7 en de subclauses ervan zijn een samenvatting van het gecombineerde effect van:

• de regels voor impliciete numerieke conversies (§10.2.3);
• de regels voor een betere omzetting (§12.6.4.7); en
• de beschikbare rekenkundige (§12.12), relationele operatoren (§12.14) en integrale logische operatoren (§12.15.2).

Numerieke promotie bestaat uit het automatisch uitvoeren van bepaalde impliciete conversies van de operanden van de vooraf gedefinieerde unaire en binaire numerieke operatoren. Numerieke promotie is geen afzonderlijk mechanisme, maar een effect van het toepassen van overbelastingsresolutie op de vooraf gedefinieerde operators. Numerieke promotie heeft specifiek geen invloed op de evaluatie van door de gebruiker gedefinieerde operators, hoewel door de gebruiker gedefinieerde operators kunnen worden geïmplementeerd om vergelijkbare effecten te vertonen.

Als voorbeeld van numerieke promotie kunt u rekening houden met de vooraf gedefinieerde implementaties van de binaire *-operator:

int operator *(int x, int y);
uint operator *(uint x, uint y);
long operator *(long x, long y);
ulong operator *(ulong x, ulong y);
float operator *(float x, float y);
double operator *(double x, double y);
decimal operator *(decimal x, decimal y);

Wanneer overbelastingsoplossingsregels (§12.6.4) worden toegepast op deze set operators, is het effect het selecteren van de eerste operatoren waarvoor impliciete conversies bestaan uit de operandtypen.

voorbeeld: voor de bewerking b * s, waarbij b een byte is en s een shortis, selecteert overbelastingsresolutie operator *(int, int) als de beste operator. Het effect is dus dat b en s worden geconverteerd naar int, en het type van het resultaat is int. Voor de bewerking i * d, waarbij i een int is en d een doubleis, selecteert overload resolutie operator *(double, double) als de beste operator. einde voorbeeld

einde van informatieve tekst.

12.4.7.2 Unaire numerieke promoties

Deze subclause is informatief.

Unaire numerieke promotie vindt plaats voor de operanden van de vooraf gedefinieerde +, -en ~ unaire operatoren. Unaire numerieke promotie bestaat eenvoudig uit het converteren van operanden van het type sbyte, byte, short, ushortof char om intte typen . Daarnaast converteert de unaire numerieke promotie operanden van het type uint naar type longvoor de unaire – operator.

einde van informatieve tekst.

12.4.7.3 Binaire numerieke promoties

Deze subclause is informatief.

Binaire numerieke promotie vindt plaats voor de operanden van de vooraf gedefinieerde +, -, *, /, %, &, |, ^, ==, !=, >, <, >=en <= binaire operatoren. Binaire numerieke promotie converteert impliciet beide operanden naar een gemeenschappelijk type dat, in het geval van de niet-relationele operatoren, ook het resultaattype van de bewerking wordt. Binaire numerieke promotie bestaat uit het toepassen van de volgende regels, in de volgorde waarin ze hier worden weergegeven:

• Als een operand van het type decimalis, wordt de andere operand geconverteerd naar het type decimalof treedt er een bindingstijdfout op als de andere operand van het type float of doubleis.
• Als een van beide operanden van het type doubleis, wordt de andere operand geconverteerd naar het type double.
• Als een van beide operanden van het type floatis, wordt de andere operand geconverteerd naar het type float.
• Als een operand van het type ulongis, wordt de andere operand geconverteerd naar het type ulongof treedt er een bindingstijdfout op als de andere operand van type sbyte, short, intof longis.
• Als een van beide operanden van het type longis, wordt de andere operand geconverteerd naar het type long.
• Als een operand van het type uint is en de andere operand van het type sbyte, shortof int, worden beide operanden geconverteerd naar het type long.
• Als een van beide operanden van het type uintis, wordt de andere operand geconverteerd naar het type uint.
• Anders worden beide operanden geconverteerd naar het type int.

Opmerking: De eerste regel verbiedt bewerkingen die het decimal-type combineren met de typen double en float. De regel volgt uit het feit dat er geen impliciete conversies zijn tussen het decimal type en de double en float typen. eindnotitie

Opmerking: houd er ook rekening mee dat het niet mogelijk is dat een operand van het type ulong is wanneer de andere operand van een ondertekend integraal type is. De reden hiervoor is dat er geen integraal type bestaat dat het volledige bereik van ulong en de ondertekende integrale typen kan vertegenwoordigen. eindnotitie

In beide bovenstaande gevallen kan een cast-expressie worden gebruikt om één operand expliciet te converteren naar een type dat compatibel is met de andere operand.

Voorbeeld: In de volgende code

decimal AddPercent(decimal x, double percent) =>
    x * (1.0 + percent / 100.0);

er treedt een bindingstijdfout op omdat een decimal niet kan worden vermenigvuldigd met een double. De fout wordt opgelost door de tweede operand expliciet te converteren naar decimal, als volgt:

decimal AddPercent(decimal x, double percent) =>
    x * (decimal)(1.0 + percent / 100.0);

einde voorbeeld

einde van informatieve tekst.

12.4.8 Gelifte operatoren

Met een lifted operator kunnen vooraf gedefinieerde en door de gebruiker gedefinieerde operatoren die op een niet-nullbaar waardetype werken, ook worden gebruikt met de null-vorm van dat type. Lifted operators zijn samengesteld uit vooraf gedefinieerde en door de gebruiker gedefinieerde operators die voldoen aan bepaalde vereisten, zoals hieronder beschreven.

• Voor de unaire operatoren , , , , +++ (logische negatie) -en , bestaat --er een opgeheven vorm van een operator als de operand- en resultaattypen beide niet-null-waardetypen zijn. !^~ Het opgeheven formulier wordt samengesteld door één ? modificator toe te voegen aan operand- en resultaattypen. De gelifte operator produceert een null-waarde als de operand nullis. Anders pakt de lifted operator de operand uit, past de onderliggende operator toe en omhult het resultaat.
• Voor de binaire operatoren +, -, *, /, %, &, |, , ^, ..en <<>>, bestaat er een opgeheven vorm van een operator als de operand en resultaattypen alle niet-null-waardetypen zijn. De opgetilde vorm wordt samengesteld door een enkele ? modifier toe te voegen aan elke operand en het resultaattype. De lifted operator produceert een null waarde als een of beide operanden zijn null (een uitzondering: de & operatoren | van het bool? type, zoals beschreven in §12.15.5). Anders haalt de opgetilde operator de operanden uit, past de onderliggende operator toe en verpakt het resultaat.
• Voor de gelijkheidsoperatoren == en !=bestaat er een getilde vorm van een operator als de operandtypen zowel niet-nulwaarde-typen zijn, én het resultaattype is bool. Het opgeheven formulier wordt samengesteld door één ? modifier toe te voegen aan elk operandtype. De gelifte operator beschouwt twee null-waarden als gelijk en een null-waarde als ongelijk aan elke waarde die geennull is. Als beide operanden niet-null zijn, haalt de verhoogde operator de operanden uit en past de basisoperator toe om het bool resultaat te produceren.
• Voor de relationele operatoren <, >, <=en >=, bestaat er een opgeheven vorm van een operator als de operandtypen zowel niet-nullable waardetypen zijn als het resultaattype is bool. Het opgeheven formulier wordt samengesteld door één ? modifier toe te voegen aan elk operandtype. De gelifte operator levert de waarde false als een of beide operanden nullzijn. Anders pakt de lifted operator de operanden uit en past de onderliggende bewerking toe om het resultaat bool te verkrijgen.

12.5 Ledenzoekactie

12.5.1 Algemeen

Een ledenopzoekactie is het proces waarbij de betekenis van een naam in de context van een type wordt vastgesteld. Een lidzoekactie kan optreden als onderdeel van het evalueren van een simple_name (§12.8.4) of een member_access (§12.8.7) in een expressie. Als de simple_name of member_access optreedt als de primary_expression van een invocation_expression (§12.8.10.2), wordt het lid aangeroepen.

Als een lid een methode of gebeurtenis is, of als het een constante, veld of eigenschap is van een gemachtigde (§21) of het type dynamic (§8.2.4), wordt het lid geacht aan te roepen.

Bij het opzoeken van leden wordt niet alleen rekening gebracht met de naam van een lid, maar ook met het aantal parameters van het type dat het lid heeft en of het lid toegankelijk is. Voor het opzoeken van leden hebben algemene methoden en geneste algemene typen het aantal typeparameters aangegeven in hun respectieve declaraties en alle andere leden hebben nultypeparameters.

Het opzoeken van een lid met de naam N met K typeargumenten in een type T wordt als volgt verwerkt:

• Eerst wordt een set toegankelijke leden met de naam N bepaald:
  • Als T een typeparameter is, is de set de samenvoeging van de sets toegankelijke leden met de naam N in elk van de typen die zijn opgegeven als een primaire beperking of secundaire beperking (§15.2.5) voor T, samen met de set toegankelijke leden met de naam N in object.
  • Anders bestaat de set uit alle toegankelijke leden (§7,5) met de naam N in T, inclusief overgenomen leden en de toegankelijke leden met de naam N in object. Als T een samengesteld type is, wordt de set leden verkregen door typeargumenten te vervangen zoals beschreven in §15.3.3. Leden met een override modifier worden uitgesloten van de set.
• Als K nul is, worden alle geneste typen waarvan de declaraties typeparameters bevatten, verwijderd. Als K niet nul is, worden alle leden met een ander aantal typeparameters verwijderd. Wanneer K nul is, worden methoden met typeparameters niet verwijderd, omdat het typedeductieproces (§12.6.3) mogelijk de typeargumenten kan afleiden.
• Als het lid vervolgens wordt aangeroepen, worden alle niet-aanroepbare leden uit de set verwijderd.
• Vervolgens worden leden die door andere leden zijn verborgen, uit de set verwijderd. Voor elk lid S.M in de set, waarbij S het type is waarin het lid M wordt gedeclareerd, worden de volgende regels toegepast:
  • Als M een constant, veld, eigenschap, gebeurtenis of opsommingslid is, worden alle leden die zijn gedeclareerd in een basistype S uit de set verwijderd.
  • Als M een typedeclaratie is, worden alle niet-typen die zijn gedeclareerd in een basistype van S uit de set verwijderd en worden alle typedeclaraties met hetzelfde aantal typeparameters verwijderd als M gedeclareerd in een basistype van S uit de set worden verwijderd.
  • Als M een methode is, worden alle niet-methodeleden die zijn gedeclareerd in een basistype van S uit de set verwijderd.
• Vervolgens worden interfaceleden die door klasseleden worden verborgen, uit de set verwijderd. Deze stap heeft alleen een effect als T een typeparameter is en T zowel een effectieve basisklasse heeft dan object als een niet-lege effectieve interfaceset (§15.2.5). Voor elk lid S.M in de set, waarbij S het type is waarin het lid M wordt gedeclareerd, worden de volgende regels toegepast als S een andere klassedeclaratie is dan object:
  • Als M een constante, veld, eigenschap, gebeurtenis, opsommingslid of typedeclaratie is, worden alle leden die in een interfacedeclaratie zijn gedeclareerd, verwijderd uit de set.
  • Als M een methode is, worden alle niet-methodeleden die zijn gedeclareerd in een interfacedeclaratie uit de set verwijderd en worden alle methoden met dezelfde handtekening als M die zijn gedeclareerd in een interfacedeclaratie uit de set verwijderd.
• Ten slotte wordt het resultaat van de zoekactie bepaald nadat verborgen leden zijn verwijderd:
  • Als de set bestaat uit één lid dat geen methode is, is dit lid het resultaat van de opzoekactie.
  • Als de set alleen methoden bevat, is deze groep methoden het resultaat van de opzoekactie.
  • Anders is de zoekactie dubbelzinnig en treedt er een bindingstijdfout op.

Voor lidzoekacties in typen anders dan typeparameters en interfaces, evenals lidzoekacties in interfaces die strikt sprake zijn van enkele overerving (waarbij elke interface in de overnameketen precies nul of één directe basisinterface heeft), is het effect van de opzoekregels simpelweg dat afgeleide leden basiselementen met dezelfde naam of handtekening verbergen. Dergelijke opzoekingen met enkele overerving zijn nooit dubbelzinnig. De dubbelzinnigheden die kunnen ontstaan door lidzoekacties in interfaces met meerdere overnames, worden beschreven in §19.4.11.

Opmerking: Deze fase houdt slechts rekening met één soort dubbelzinnigheid. Als het opzoeken van leden resulteert in een methodegroep, kan het gebruik van een methodegroep mislukken vanwege dubbelzinnigheid, zoals beschreven in §12.6.4.1 en §12.6.6.2. eindnotitie

12.5.2 Basistypen

Voor het opzoeken van leden wordt een type T geacht te bestaan uit de volgende basistypen:

• Als T is object of dynamic, heeft T geen basistype.
• Als T een enum_typeis, zijn de basistypen van T de klassetypen System.Enum, System.ValueTypeen object.
• Als T een struct_typeis, zijn de basistypen van T de klassetypen System.ValueType en object.

  Opmerking: een nullable_value_type is een struct_type (§8.3.1). eindnotitie

• Als T een class_typeis, zijn de basistypen van T de basisklassen van T, inclusief het klassetype object.
• Als T een interface_typeis, zijn de basistypen van T de basisinterfaces van T en het klassetype object.
• Als T een array_typeis, zijn de basistypen van T de klassetypen System.Array en object.
• Als T een delegate_typeis, zijn de basistypen van T de klassetypen System.Delegate en object.

12.6 Functieleden

12.6.1 Algemeen

Functieleden zijn leden die uitvoerbare instructies bevatten. Functieleden zijn altijd leden van typen en kunnen geen lid zijn van naamruimten. C# definieert de volgende categorieën functieleden:

• Methoden
• Eigenschappen
• Gebeurtenissen
• Indexeerders
• Door de gebruiker gedefinieerde operators
• Instantieconstructors
• Statische constructors
• Finaliseerders

Met uitzondering van finalizers en statische constructors (die niet expliciet kunnen worden aangeroepen), worden de instructies in functieleden uitgevoerd via aanroepen van functieleden. De werkelijke syntaxis voor het schrijven van een aanroep van een functielid is afhankelijk van de specifieke categorie van het functielid.

De argumentenlijst (§12.6.2) van een aanroep van een functielid bevat werkelijke waarden of variabele verwijzingen voor de parameters van het functielid.

Aanroepen van algemene methoden kunnen gebruikmaken van typedeductie om de set typeargumenten te bepalen die aan de methode moeten worden doorgegeven. Dit proces wordt beschreven in §12.6.3.

Aanroepen van methoden, indexeerfuncties, operators en instantieconstructors maken gebruik van overbelastingsresolutie om te bepalen welke van een kandidaat-set functieleden moet worden aangeroepen. Dit proces wordt beschreven in §12.6.4.

Zodra een bepaald functielid tijdens bindingstijd is geïdentificeerd, mogelijk via overbelastingsresolutie, wordt het werkelijke runtimeproces voor het aanroepen van het functielid beschreven in §12.6.6.

Opmerking: de volgende tabel bevat een overzicht van de verwerking die plaatsvindt in constructies met de zes categorieën functieleden die expliciet kunnen worden aangeroepen. In de tabel geven e, x, yen value expressies aan die zijn geclassificeerd als variabelen of waarden, T een expressie aangeeft die is geclassificeerd als een type, F de eenvoudige naam van een methode is en P de eenvoudige naam van een eigenschap is.

Bouwen	Voorbeeld	Beschrijving
Methode-aanroep	F(x, y)	Overbelastingsresolutie wordt toegepast om de beste methode F in de bevatte klasse of structuur te selecteren. De methode wordt aangeroepen met de argumentenlijst (x, y). Als de methode niet staticis, is de instantie-expressie this.
	T.F(x, y)	Overbelastingsresolutie wordt toegepast om de beste methode te selecteren F in de klasse of struct T. Er treedt een fout op tijdens de bindtijd als de methode niet staticis. De methode wordt aangeroepen met de argumentenlijst (x, y).
	e.F(x, y)	Overbelastingresolutie wordt toegepast om de beste methode F in de klasse, struct of interface te selecteren die is opgegeven door het type e. Er treedt een bindingstijdfout op als de methode is static. De methode wordt aangeroepen met de exemplaarexpressie e en de lijst met argumenten (x, y).
Toegang tot eigenschappen	P	De 'get' accessor van de eigenschap P in de omvattende klasse of struct wordt aangeroepen. Er treedt een compilatiefout op als P schrijf-alleen is. Als P niet staticis, is de exemplaarexpressie this.
	P = value	De set accessor van de eigenschap P in de bevatde klasse of struct wordt aangeroepen met de lijst met argumenten (value). Er treedt een compilatietijdfout op als P alleen-lezen is. Als P niet staticis, is de exemplaarexpressie this.
	T.P	De toegangsfunctie 'get' van de eigenschap P in de klasse of structuur T wordt aangeroepen. Er treedt een compilatiefout op als P niet static is of als P alleen-voor-schrijven is.
	T.P = value	De set accessor van de eigenschap P in de klasse of struct T wordt aangeroepen met de argumentenlijst (value). Er treedt een compilatiefout op als P niet static is of als P alleen lezen is.
	e.P	De get-accessor van de eigenschap P in de klasse, structuur of interface zoals opgegeven door het type E, wordt aangeroepen met de instantietie-expressie e. Er treedt een bindingstijdfout op als Pstatic is of als P alleen voor schrijven is.
	e.P = value	De settoegangsfunctie van de eigenschap P in de klasse, struct of interface die wordt opgegeven door het type E wordt aangeroepen met de exemplaarexpressie e en de lijst met argumenten (value). Er treedt een bindtijdfout op als Pstatic is of als P alleen-lezen is.
Toegang tot gebeurtenissen	E += value	De add accessor van de gebeurtenis E in de bevatde klasse of struct wordt aangeroepen. Als E niet staticis, is de exemplaarexpressie this.
	E -= value	De verwijdertoegangsfunctie van de gebeurtenis E in de bevattende Klasse of struct wordt aangeroepen. Als E niet staticis, is de exemplaarexpressie this.
	T.E += value	De add accessor van de gebeurtenis E in de klasse of struct T wordt aangeroepen. Er treedt een bindingstijdfout op als E niet is static.
	T.E -= value	De remove-toegangsfunctie van de gebeurtenis E in de klasse of struct T wordt aangeroepen. Er treedt een bindingstijdfout op als E niet is static.
	e.E += value	De add accessor van de gebeurtenis E in de klasse, struct of interface die wordt opgegeven door het type E, wordt aangeroepen met de expressie van de instantie e. Er treedt een bindingstijdfout op als E is static.
	e.E -= value	De verwijdertoegangsmethode van de gebeurtenis E in de klasse, struct of interface, zoals gegeven door het type E, wordt aangeroepen met de exemplaarexpressie e. Er treedt een bindingstijdfout op als E is static.
Toegang tot indexeerfunctie	e[x, y]	Overbelasting resolutie is van toepassing voor het selecteren van de beste indexer in de klasse, struct of interface die wordt gegeven door het type e. De get-accessor van de indexer wordt aangeroepen met de instantiefunctie e en de argumentenlijst (x, y). Er treedt een bindingstijdfout op als de indexeerfunctie alleen-schrijven is.
	e[x, y] = value	Overbelasting resolutie is van toepassing voor het selecteren van de beste indexer in de klasse, struct of interface die wordt gegeven door het type e. De set accessor van de indexeerfunctie wordt aangeroepen met de exemplaarexpressie e en de argumentenlijst (x, y, value). Er treedt een bindingstijdfout op als de indexeerfunctie alleen-lezen is.
Operator aanroepen	-x	Overbelastingsresolutie wordt toegepast om de beste unaire operator in de klasse of struct te selecteren die is opgegeven door het type x. De geselecteerde operator wordt aangeroepen met de lijst met argumenten (x).
	x + y	Overbelastingsresolutie wordt toegepast om de beste binaire operator te selecteren in de klassen of structs die worden gegeven door de typen x en y. De geselecteerde operator wordt aangeroepen met de lijst met argumenten (x, y).
Aanroep van exemplaarconstructor	new T(x, y)	Overbelastingsresolutie wordt toegepast om de beste instantieconstructor in de klasse of struct Tte selecteren. De instantieconstructor wordt aangeroepen met de lijst met argumenten (x, y).

eindnotitie

12.6.2 Argumentlijsten

12.6.2.1 Algemeen

Elk functielid en gemachtigde aanroep bevat een lijst met argumenten, die werkelijke waarden of variabele verwijzingen biedt voor de parameters van het functielid. De syntaxis voor het opgeven van de argumentenlijst van een aanroep van een functielid is afhankelijk van de categorie functielid:

• Voor bijvoorbeeld constructors, methoden, indexeerfuncties en gemachtigden worden de argumenten opgegeven als een argument_list, zoals hieronder wordt beschreven. Voor indexeerders, bij het aanroepen van de set-accessor, bevat de argumentenlijst ook de expressie die is opgegeven als de rechteroperand van de toewijzingsoperator.

  Opmerking: dit extra argument wordt niet gebruikt voor overload-resolutie, alleen tijdens het aanroepen van de set-accessor. eindnotitie

• Voor eigenschappen is de lijst met argumenten leeg bij het aanroepen van de get-accessor en bestaat deze uit de expressie die is opgegeven als de rechteroperand van de toewijzingsoperator bij het aanroepen van de set-accessor.
• Voor gebeurtenissen bestaat de lijst met argumenten uit de expressie die is opgegeven als de rechteroperand van de operator += of -=.
• Voor door de gebruiker gedefinieerde operators bestaat de lijst met argumenten uit één operand van de unaire operator of de twee operanden van de binaire operator.

De argumenten van eigenschappen (§15,7) en gebeurtenissen (§15,8) worden altijd doorgegeven als waardeparameters (§15.6.2.2). De argumenten van door de gebruiker gedefinieerde operatoren (§15.10) worden altijd doorgegeven als waardeparameters (§15.6.2.2) of invoerparameters (§9.2.8). De argumenten van indexeerfuncties (§15,9) worden altijd doorgegeven als waardeparameters (§15.6.2.2), invoerparameters (§9.2.8), of parametermatrices (§15.6.2.4). Uitvoer- en referentieparameters worden niet ondersteund voor deze categorieën functieleden.

De argumenten van een instantieconstructor, methode, indexeerfunctie of gemachtigde aanroep worden opgegeven als een argument_list:

argument_list
    : argument (',' argument)*
    ;

argument
    : argument_name? argument_value
    ;

argument_name
    : identifier ':'
    ;

argument_value
    : expression
    | 'in' variable_reference
    | 'ref' variable_reference
    | 'out' variable_reference
    ;

Een argument_list bestaat uit een of meer arguments, gescheiden door komma's. Elk argument bestaat uit een optionele argument_name gevolgd door een argument_value. Een argument met een argument_name wordt een benoemd argumentgenoemd, terwijl een argument zonder argument_name een positioneel argumentis.

De argument_value kan een van de volgende vormen aannemen:

• Een expressie, waarmee wordt aangegeven dat het argument wordt doorgegeven als waardeparameter of wordt omgezet in een invoerparameter en vervolgens wordt doorgegeven als die, zoals bepaald door (§12.6.4.2 en wordt beschreven in §12.6.2.3.
• Het trefwoord in gevolgd door een variable_reference (§9,5), waarmee wordt aangegeven dat het argument wordt doorgegeven als invoerparameter (§15.6.2.3.2). Een variabele moet zeker worden toegewezen (§9.4) voordat deze kan worden doorgegeven als invoerparameter.
• Het trefwoord ref gevolgd door een variable_reference (§9,5), waarmee wordt aangegeven dat het argument wordt doorgegeven als referentieparameter (§15.6.2.3.3). Een variabele moet zeker worden toegewezen (§9.4) voordat deze kan worden doorgegeven als referentieparameter.
• Het trefwoord out gevolgd door een variable_reference (§9,5), waarmee wordt aangegeven dat het argument wordt doorgegeven als een uitvoerparameter (§15.6.2.3.4). Een variabele wordt beschouwd als definitief toegewezen (§9.4) na een functielidaanroep waarin de variabele wordt doorgegeven als een uitvoerparameter.

Het formulier bepaalt de modus voor het doorgeven van parameters van het argument: respectievelijk waarde, invoer, verwijzingof uitvoer. Zoals hierboven vermeld, kan een argument met de modus voor het doorgeven van waarden echter worden omgezet in een argument met de invoerdoorgiftemodus.

Het doorgeven van een vluchtig veld (§15.5.4) als invoer-, uitvoer- of referentieparameter veroorzaakt een waarschuwing, omdat het veld niet kan worden behandeld als vluchtig door de aangeroepen methode.

12.6.2.2 Corresponderende parameters

Voor elk argument in een argumentenlijst moet er een bijbehorende parameter zijn in het functielid of de gedelegeerde die wordt aangeroepen.

De parameterlijst die in het volgende wordt gebruikt, wordt als volgt bepaald:

• Voor virtuele methoden en indexeringsfuncties die in klassen zijn gedefinieerd, wordt de parameterlijst gekozen uit de eerste declaratie of override van het functielid dat wordt gevonden door te beginnen met het statische type van de ontvanger en door te zoeken in de basisklassen.
• Voor gedeeltelijke methoden wordt de parameterlijst van de declaratie voor gedeeltelijke methoden gebruikt.
• Voor alle andere functieleden en gemachtigden is er slechts één lijst met parameters. Dit is de lijst die wordt gebruikt.

De positie van een argument of parameter wordt gedefinieerd als het aantal argumenten of parameters dat eraan voorafgaat in de argumentenlijst of parameterlijst.

De bijbehorende parameters voor argumenten voor functieleden worden als volgt ingesteld:

• Argumenten in het argument_list van exemplaarconstructors, methoden, indexers en delegeren:
  • Een positioneel argument waarbij een parameter zich op dezelfde positie in de parameterlijst bevindt, komt overeen met die parameter, tenzij de parameter een parametermatrix is en het functielid wordt aangeroepen in de uitgevouwen vorm.
  • Een positioneel argument van een functielid met een parametermatrix die wordt aangeroepen in de uitgevouwen vorm, die plaatsvindt op of na de positie van de parametermatrix in de parameterlijst, komt overeen met een element in de parametermatrix.
  • Een benoemd argument komt overeen met de parameter van dezelfde naam in de parameterlijst.
  • Bij het aanroepen van de set-accessor komt de expressie die is opgegeven als de rechteroperand van de toewijzingsoperator overeen met de impliciete value parameter van de set-accessor-declaratie.
• Bij het aanroepen van de get-accessor zijn er geen argumenten voor eigenschappen. Wanneer u de settoegangsfunctie aanroept, komt de expressie die is opgegeven als de rechteroperand van de toewijzingsoperator overeen met de impliciete waardeparameter van de declaratie van de settoegangsfunctie.
• Voor door de gebruiker gedefinieerde unaire operators (inclusief conversies) komt de enkele operand overeen met de enkele parameter van de operatordeclaratie.
• Voor door de gebruiker gedefinieerde binaire operatoren komt de linkeroperand overeen met de eerste parameter en komt de rechteroperand overeen met de tweede parameter van de operatordeclaratie.
• Een niet-benoemd argument komt overeen met geen parameter wanneer deze zich achter een argument met een buiten positie bevindt of een benoemd argument dat overeenkomt met een parametermatrix.

  Opmerking: hiermee voorkomt u dat void M(bool a = true, bool b = true, bool c = true); wordt aangeroepen door M(c: false, valueB);. Het eerste argument wordt buiten positie gebruikt (het argument wordt gebruikt op de eerste positie, maar de parameter met de naam c zich op de derde positie bevindt), dus de volgende argumenten moeten worden benoemd. Met andere woorden, niet-gevolgde benoemde argumenten zijn alleen toegestaan wanneer de naam en de positie resulteren in het vinden van dezelfde corresponderende parameter. eindnotitie

12.6.2.3 Runtime-evaluatie van argumentlijsten

Tijdens de uitvoering van de aanroep van een functielid (§12.6.6), worden de expressies of variabele verwijzingen van een lijst met argumenten als volgt geëvalueerd, van links naar rechts:

• Als voor een waardeargument de doorgangsmodus van de parameter een waarde is

  • de argumentexpressie wordt geëvalueerd en er wordt een impliciete conversie (§10.2) uitgevoerd op het bijbehorende parametertype. De resulterende waarde wordt de initiële waarde van de waardeparameter in de aanroep van het functielid.

  • anders is de passeermodus van de parameter invoer. Als het argument een variabele verwijzing is en er een identiteitsconversie bestaat (§10.2.2) tussen het type van het argument en het type van de parameter, wordt de resulterende opslaglocatie de opslaglocatie die wordt vertegenwoordigd door de parameter in de aanroep van het functielid. Anders wordt er een opslaglocatie gemaakt met hetzelfde type als die van de bijbehorende parameter. De argumentexpressie wordt geëvalueerd en er wordt een impliciete conversie (§10.2) uitgevoerd naar het bijbehorende parametertype. De resulterende waarde wordt opgeslagen in die opslaglocatie. Deze opslaglocatie wordt vertegenwoordigd door de invoerparameter in de aanroep van het functielid.

    Voorbeeld: Gegeven de volgende declaraties en methodeaanroepen:

    static void M1(in int p1) { ... }
    int i = 10;
    M1(i);         // i is passed as an input argument
    M1(i + 5);     // transformed to a temporary input argument
    

    In de M1(i) methodeaanroep wordt i zelf doorgegeven als invoerargument, omdat deze is geclassificeerd als een variabele en hetzelfde type heeft int als de invoerparameter. In de M1(i + 5) methodeaanroep wordt een niet-benoemde int variabele gemaakt, geïnitialiseerd met de waarde van het argument en vervolgens doorgegeven als invoerargument. Zie §12.6.4.2 en §12.6.4.4.

    einde voorbeeld

• Voor een invoer-, uitvoer- of verwijzingsargument wordt de variabelereferentie geëvalueerd en wordt de resulterende opslaglocatie de opslaglocatie die wordt vertegenwoordigd door de parameter in de aanroep van het functielid. Voor een invoer- of verwijzingsargument wordt de variabele zeker toegewezen aan het punt van de methodeaanroep. Als de variabeleverwijzing wordt opgegeven als een uitvoerargument of een matrixelement van een reference_typeis, wordt er een runtimecontrole uitgevoerd om ervoor te zorgen dat het elementtype van de matrix identiek is aan het type van de parameter. Als deze controle mislukt, wordt er een System.ArrayTypeMismatchException gegenereerd.

Opmerking: deze runtimecontrole is vereist vanwege de covariantie van de matrix (§17,6). eindnotitie

Voorbeeld: In de volgende code

class Test
{
    static void F(ref object x) {...}

    static void Main()
    {
        object[] a = new object[10];
        object[] b = new string[10];
        F(ref a[0]); // Ok
        F(ref b[1]); // ArrayTypeMismatchException
    }
}

de tweede aanroep van F zorgt ervoor dat een System.ArrayTypeMismatchException wordt gegenereerd omdat het werkelijke elementtype van bstring is en niet object.

einde voorbeeld

Methoden, indexeerfuncties en instantieconstructors kunnen de meest rechtse parameter declareren als een parametermatrix (§15.6.2.4). Dergelijke functieleden worden aangeroepen in hun normale vorm of in hun uitgebreide vorm, afhankelijk van wat van toepassing is (§12.6.4.2):

• Wanneer een functielid met een parametermatrix wordt aangeroepen in de normale vorm, is het argument voor de parametermatrix een enkele expressie die impliciet kan worden omgezet (§10.2) voor het parametermatrixtype. In dit geval fungeert de parametermatrix precies als een waardeparameter.
• Wanneer een functielid met een parametermatrix wordt aangeroepen in de uitgevouwen vorm, geeft de aanroep nul of meer positionele argumenten op voor de parametermatrix, waarbij elk argument een expressie is die impliciet kan worden omgezet (§10.2) aan het elementtype van de parametermatrix. In dit geval maakt de aanroep een exemplaar van het parametertabeltype met een lengte die overeenkomt met het aantal argumenten, initialiseert de elementen van de tabelinstantie met de opgegeven argumentwaarden en wordt de zojuist aangemaakte tabelinstantie gebruikt als het werkelijke argument.

De expressies van een lijst met argumenten worden altijd in tekstvolgorde geëvalueerd.

Voorbeeld: Daarom het voorbeeld

class Test
{
    static void F(int x, int y = -1, int z = -2) =>
        Console.WriteLine($"x = {x}, y = {y}, z = {z}");

    static void Main()
    {
        int i = 0;
        F(i++, i++, i++);
        F(z: i++, x: i++);
    }
}

produceert de uitvoer

x = 0, y = 1, z = 2
x = 4, y = -1, z = 3

einde voorbeeld

Wanneer een functielid met een parametermatrix wordt aangeroepen in de uitgevouwen vorm met ten minste één uitgevouwen argument, wordt de aanroep verwerkt alsof een expressie voor het maken van een matrix met een matrixinitiizer (§12.8.17.4) rond de uitgebreide argumenten is ingevoegd. Er wordt een lege matrix doorgegeven wanneer er geen argumenten zijn voor de parametermatrix; het is niet opgegeven of de verwijzing die is doorgegeven aan een nieuw toegewezen of bestaande lege matrix is.

Voorbeeld: Gegeven de declaratie

void F(int x, int y, params object[] args);

de volgende aanroepen van de uitgebreide methodenvorm

F(10, 20, 30, 40);
F(10, 20, 1, "hello", 3.0);

precies overeenkomen met

F(10, 20, new object[] { 30, 40 });
F(10, 20, new object[] { 1, "hello", 3.0 });

einde voorbeeld

Wanneer argumenten worden weggelaten van een functielid met bijbehorende optionele parameters, worden de standaardargumenten van de declaratie van het functielid impliciet doorgegeven. (Dit kan betrekking hebben op het maken van een opslaglocatie, zoals hierboven beschreven.)

Opmerking: omdat deze altijd constant zijn, heeft de evaluatie geen invloed op de evaluatie van de resterende argumenten. eindnotitie

12.6.3 Type inferentie

12.6.3.1 Algemeen

Wanneer een algemene methode wordt aangeroepen zonder typeargumenten op te geven, probeert een typedeductie proces argumenten voor de aanroep af te stellen. Door de aanwezigheid van typedeductie kan een handigere syntaxis worden gebruikt voor het aanroepen van een algemene methode en kan de programmeur voorkomen dat redundante typegegevens worden opgegeven.

voorbeeld van:

class Chooser
{
    static Random rand = new Random();

    public static T Choose<T>(T first, T second) =>
        rand.Next(2) == 0 ? first : second;
}

class A
{
    static void M()
    {
        int i = Chooser.Choose(5, 213); // Calls Choose<int>
        string s = Chooser.Choose("apple", "banana"); // Calls Choose<string>
    }
}

Door middel van typedeductie worden de typeargumenten int en string bepaald van de argumenten tot de methode.

einde voorbeeld

Typedeductie vindt plaats als onderdeel van de bindingstijdverwerking van een methode-aanroep (§12.8.10.2) en vindt plaats vóór de overbelastingsresolutiestap van de aanroep. Wanneer een bepaalde methodegroep wordt opgegeven in een methode-aanroep en er geen typeargumenten worden opgegeven als onderdeel van de aanroep van de methode, wordt typedeductie toegepast op elke algemene methode in de methodegroep. Als de type-inferentie slaagt, worden de afgeleide typeargumenten gebruikt om de typen van argumenten voor de volgende overbelastingsoplossing te bepalen. Als overbelastingsresolutie een algemene methode kiest als de methode die moet worden aangeroepen, worden de uitgestelde typeargumenten gebruikt als de typeargumenten voor de aanroep. Als typedeductie voor een bepaalde methode mislukt, neemt die methode niet deel aan overbelastingsresolutie. De fout van typedeductie, op en van zichzelf, veroorzaakt geen bindingstijdfout. Het leidt echter vaak tot een bindingstijdfout wanneer overbelastingsoplossing geen toepasselijke methoden kan vinden.

Als elk opgegeven argument niet overeenkomt met precies één parameter in de methode (§12.6.2.2), of als er een niet-optionele parameter zonder corresponderend argument is, mislukt deductie onmiddellijk. Anders wordt ervan uitgegaan dat de algemene methode de volgende handtekening heeft:

Tₑ M<X₁...Xᵥ>(T₁ p₁ ... Tₓ pₓ)

Met een methodeoproep van het formulier M(E₁ ...Eₓ) de taak van typedeductie is het vinden van unieke typeargumenten S₁...Sᵥ voor elk van de typeparameters X₁...Xᵥ, zodat de aanroep M<S₁...Sᵥ>(E₁...Eₓ) geldig wordt.

Het proces van typedeductie wordt hieronder beschreven als een algoritme. Een conforme compiler kan worden geïmplementeerd met behulp van een alternatieve benadering, mits deze in alle gevallen hetzelfde resultaat bereikt.

Tijdens het proces van inferentie wordt elke typeparameter Xᵢ ofwel vastgelegd op een bepaald type Sᵢ, ofwel niet-vastgelegd met een bijbehorende set van beperkingen. Elk van de beperkingen is een bepaald type T. In eerste instantie is elke typevariabele Xᵢ niet vastgelegd en heeft geen grenzen.

Typedeductie vindt plaats in fasen. Elke fase probeert argumenten voor meer typevariabelen af te stellen op basis van de bevindingen van de vorige fase. In de eerste fase worden enkele initiële afleidingen van grenzen gemaakt, terwijl in de tweede fase typevariabelen worden vastgelegd op specifieke typen en meer grenzen worden afgeleid. De tweede fase moet mogelijk een aantal keren worden herhaald.

Opmerking: Typedeductie wordt ook gebruikt in andere contexten, waaronder voor de conversie van methodegroepen (§12.6.3.15) en het vinden van het beste algemene type van een set expressies (§12.6.3.16). eindnotitie

12.6.3.2 De eerste fase

Voor elk van de methodeargumenten Eᵢwordt een invoertypedeductie (§12.6.3.7) gemaakt van Eᵢ het overeenkomstige parametertype Tⱼ.

12.6.3.3 De tweede fase

De tweede fase gaat als volgt:

• Alle niet-opgeloste typevariabelen Xᵢ die niet afhankelijk zijn van (§12.6.3.6) zijn Xₑ vast (§12.6.3.13).
• Als er geen dergelijke typevariabelen bestaan, worden alle niet-vaste typevariabelen Xᵢvastgezet waarvoor alle volgende voorwaarden gelden:
  • Er is ten minste één typevariabele Xₑ die afhankelijk is vanXᵢ
  • Xᵢ heeft een niet-lege set grenzen
• Als er geen dergelijke typevariabelen bestaan en er nog steeds niet-vastgefixeerde typevariabelen zijn, mislukt deductie.
• Anders, als er verder geen niet-opgeloste typevariabelen bestaan, dan slaagt de type-inferentie.
• Anders geldt dat voor alle argumenten Eᵢ met het bijbehorende parametertype Tⱼ waarbij de uitvoertypen (§12.6.3.5) niet-vastgemaakte typevariabelen Xₑ bevatten, maar de invoertypen (§12.6.3.4) niet, wordt een deductie van het uitvoertype (§12.6.3.8) gemaakt vanEᵢnaarTⱼ. Vervolgens wordt de tweede fase herhaald.

12.6.3.4 Invoertypen

Als E een methodegroep of impliciet getypte anonieme functie is en T een gedelegeerdetype of expressieboomtype is, dan zijn alle parametertypen van Tinvoertypen vanEmet het typeT.

12.6.3.5 Uitvoertypen

Als E een methodegroep of een anonieme functie is en T een type gedelegeerde of expressiestructuur is, is het retourtype van T een uitvoertype vanEmet het typeT.

12.6.3.6 Afhankelijkheid

Een niet-opgeloste typevariabele Xᵢis rechtstreeks afhankelijk van een niet-opgeloste variabele typevariabele Xₑ als voor een bepaald argument Eᵥ type TᵥXₑ voorkomt in een invoertype van Eᵥ met het type Tᵥ en Xᵢ optreedt in een uitvoertype van Eᵥ met het type Tᵥ.

Xₑ is afhankelijk vanXᵢ als Xₑrechtstreeks afhankelijk is vanXᵢ of dat Xᵢrechtstreeks afhankelijk is vanXᵥ en Xᵥafhankelijk is vanXₑ. Dus "hangt af van" is de transitieve maar niet reflexieve sluiting van "hangt rechtstreeks af van".

12.6.3.7 Invoertypededucties

Een invoertypedeductie wordt afgeleidE een expressie naar een type T op de volgende manier:

• Als E een tuple-expressie (§12.8.6) is met arity N en elementenEᵢ, en T een tupletype is met arity met bijbehorende elementtypen N of Tₑ een null-waardetype T is en T0? een tupletype is met arity T0 dat een corresponderend elementtype Nheeft, wordt voor elk Tₑtype invoertype een invoertypedeductie Eᵢ gemaakt van Eᵢ tot Tₑ.
• Als E het een anonieme functie is, wordt een expliciete parametertypedeductie (§12.6.3.9) gemaakt vanEnaarT
• E Als er anders een type U is en de bijbehorende parameter een waardeparameter (§15.6.2.2) is, wordt een ondergrensdeductie (§12.6.3.11) gemaakt vanUnaarT.
• E Als er anders een type U is en de bijbehorende parameter een referentieparameter is (§15.6.2.3.3) of uitvoerparameter (§15.6.2.3.4), wordt een exacte deductie (§12.6.3.10) gemaakt vanUnaarT.
• E Als u een type U hebt en de bijbehorende parameter een invoerparameter is (§15.6.2.3.2) en E een invoerargument is, wordt een exacte deductie (§12.6.3.10) gemaakt vanUnaarT.
• E Als er anders een type U is en de bijbehorende parameter een invoerparameter (§15.6.2.3.2) is, wordt een ondergrensdeductie (§12.6.3.11) gemaakt vanUT
• Anders wordt er geen deductie gemaakt voor dit argument.

12.6.3.8 Uitvoertypededucties

Een uitvoertype-afleiding wordt gemaakt van een expressie Enaar een type T op de volgende manier:

• Als E een tuple-expressie met ariteit N en elementen Eᵢis en T een tupletype is met arple N met bijbehorende elementtypen Tₑ of T een null-waardetype T0? is en T0 een tupletype is met arity N dat een corresponderend elementtype Tₑheeft, wordt voor elk Eᵢ type uitvoertype deductie gemaakt van Eᵢ naar Tₑ.
• Als E dit een anonieme functie is met afgeleid retourtype U (§12.6.3.14) en T een gemachtigde type of expressiestructuur met retourtype Tₓis, wordt een ondergrensdeductie (§12.6.3.11) gemaakt vanUnaarTₓ.
• Als E een methodegroep is en T een gedelegeerd type of expressiebombomitetype is met parametertypen T₁...Tᵥ en retourtype Tₓ, en overbelastingsresolutie van E met de typen T₁...Tᵥ een enkele methode oplevert met retourtype U, dan wordt een inferentie van de ondergrens gemaakt vanUtotTₓ.
• Als E een expressie is met het type U, dan wordt er een ondergrens deductie gemaakt vanUnaarT.
• Anders worden er geen deducties gemaakt.

12.6.3.9 Expliciete parametertypededucties

Een expliciete parametertypedeductie wordt afgeleid van een expressie Enaar een type T op de volgende manier:

• Als E een expliciet getypte anonieme functie met parametertypen U₁...Uᵥ is en T een gemachtigde type of expressiestructuur is met parametertypen V₁...Vᵥ , wordt voor elke Uᵢexacte deductie (§12.6.3.10) gemaakt vanUᵢnaar het bijbehorende Vᵢ.

12.6.3.10 Exacte deducties

Een exacte afleidingvan een type Utot een type V wordt als volgt gemaakt:

• Als V een van de niet-vastgesteldeXᵢ is, wordt U toegevoegd aan de set van exacte limieten voor Xᵢ.
• Anders worden sets V₁...Vₑ en U₁...Uₑ bepaald door te controleren of een van de volgende gevallen van toepassing is:
  • V is een matrixtype V₁[...] en U is een matrixtype U₁[...] van dezelfde rang
  • V is het type V₁? en U het type U₁
  • V is een samengesteld type C<V₁...Vₑ> en U een samengesteld type C<U₁...Uₑ>
    Als een van deze gevallen van toepassing is, wordt een exacte deductie gemaakt van elke Uᵢ naar de bijbehorende Vᵢ.
• Anders worden er geen deducties gemaakt.

12.6.3.11 Ondergrensdeducties

Een ondergrensdeductie van een type U naar een type V wordt als volgt gemaakt:

• Als V een van de niet-vastgesteldeXᵢ is, wordt U toegevoegd aan de set van ondergrenzen voor Xᵢ.
• Als V het type V₁? is en U is het type U₁?, wordt er een ondergrensinferentie gemaakt van U₁ tot V₁.
• Anders worden sets U₁...Uₑ en V₁...Vₑ bepaald door te controleren of een van de volgende gevallen van toepassing is:
  • V is een matrixtype V₁[...]en U is een matrixtype U₁[...]van dezelfde rang
  • V is een van IEnumerable<V₁>, ICollection<V₁>, IReadOnlyList<V₁>>, IReadOnlyCollection<V₁> of IList<V₁> en U een enkeldimensionaal matrixtype U₁[]
  • V is een samengesteld class, struct, interface of delegate type C<V₁...Vₑ> en er is een uniek type C<U₁...Uₑ> zodanig dat U (of, als U een type parameter is, de effectieve basisklasse of een lid van de effectieve interfaceset) identiek is aan, inherits van (direct of indirect) of implementeert (direct of indirect) C<U₁...Uₑ>.
  • (De beperking 'uniekheid' betekent dat in het geval van interface C<T>{} class U: C<X>, C<Y>{}er geen deductie wordt gemaakt bij het afleiden van U tot C<T>, omdat U₁X of Ykan zijn.)
    Als een van deze gevallen van toepassing is, wordt van elke Uᵢ een deductie gemaakt op de bijbehorende Vᵢ als volgt:
  • Als Uᵢ geen referentietype is, wordt er een exacte inferentie gemaakt
  • Anders, als U een arraytype is, wordt er een ondergrensinferentie gemaakt
  • Als VC<V₁...Vₑ> is, dan is deductie afhankelijk van de i-th typeparameter van C:
    • Als deze covariant is, wordt er een ondergrensinferentie gemaakt.
    • Als het contravariant is, wordt er een bovengrensdeductie gemaakt.
    • Als deze invariant is, wordt er een exacte deductie gemaakt.
• Anders worden er geen deducties gemaakt.

12.6.3.12 Bovengrensdeducties

Een bovengrensdeductie van een type Unaar een type V wordt als volgt gemaakt:

• Als V een van de niet-vastgesteldeXᵢ is, wordt U toegevoegd aan de set bovengrens voor Xᵢ.
• Anders worden sets V₁...Vₑ en U₁...Uₑ bepaald door te controleren of een van de volgende gevallen van toepassing is:
  • U is een matrixtype U₁[...]en V is een matrixtype V₁[...]van dezelfde rang
  • U is een van IEnumerable<Uₑ>, ICollection<Uₑ>, IReadOnlyList<Uₑ>, IReadOnlyCollection<Uₑ> of IList<Uₑ> en V een enkeldimensionaal matrixtype Vₑ[]
  • U is het type U1? en V het type V1?
  • U is een geconstrueerd klasse-, struct-, interface- of gedelegeerd type C<U₁...Uₑ> en V is een class, struct, interface- of delegate-type dat (direct of indirect) verwant is aan, afkomstig is van, of implementeert (direct of indirect) een uniek type identical
  • (De 'uniekheidseis' betekent dat gezien een interface C<T>{} class V<Z>: C<X<Z>>, C<Y<Z>>{}er geen afleiding wordt gemaakt van C<U₁> naar V<Q>. Afleidingen worden niet gedaan van U₁ naar X<Q> of naar Y<Q>.)
    Als een van deze gevallen van toepassing is, wordt van elke Uᵢ een deductie gemaakt op de bijbehorende Vᵢ als volgt:
  • Als Uᵢ geen referentietype is, wordt er een exacte inferentie gemaakt
  • Als V een matrixtype is, wordt er anders een bovengrensafleiding gemaakt.
  • Als UC<U₁...Uₑ> is, dan is deductie afhankelijk van de i-th typeparameter van C:
    • Als het covariant is, wordt er een bovengrensdeductie gemaakt.
    • Als het contravariant is, wordt er een ondergrensdeductie gemaakt.
    • Als deze invariant is, wordt er een exacte deductie gemaakt.
• Anders worden er geen deducties gemaakt.

12.6.3.13 Bevestiging

Een niet-opgeloste typevariabele Xᵢ met een set grenzen is als volgt vaste:

• De set kandidaattypenUₑ begint als de set van alle typen in de set van grenzen voor Xᵢ.
• Elke grens voor Xᵢ wordt op zijn beurt onderzocht: voor elke exacte grens van Xᵢ alle typen Uₑ die niet identiek zijn aan U uit de kandidaatset worden verwijderd. Voor elke ondergrens U van Xᵢ worden alle typen Uₑ waarvoor er geen impliciete conversie van U is, uit de kandidaatset verwijderd. Voor elke bovengrens U van Xᵢ worden alle typen Uₑ waaruit er geen impliciete conversie naar U is, uit de kandidaatset verwijderd.
• Als er onder de overgebleven kandidaattypen Uₑ een uniek type V is waarop een impliciete conversie van alle andere kandidaattypen mogelijk is, wordt Xᵢ vastgezet op V.
• Anders faalt de typeafleiding.

12.6.3.14 Uitgestelde retourtype

Het uitgestelde retourtype van een anonieme functie F wordt gebruikt tijdens typedeductie en overbelastingsresolutie. Het afgeleide retourtype kan alleen worden bepaald voor een anonieme functie waarbij alle parametertypen bekend zijn, omdat ze expliciet worden opgegeven, via een anonieme functieconversie of afgeleid tijdens typedeductie bij een omsluitende generieke methodeaanroep.

De afgeleide effectieve retourtype wordt als volgt bepaald:

• Als de hoofdtekst van F een uitdrukking is die een type heeft, dan is het afgeleide effectieve retourtype van F het type van die uitdrukking.
• Als de hoofdtekst F van een blok is en de set expressies in de instructies van het blok return een best gemeenschappelijk type T heeft (§12.6.3.16), is Fhet uitgestelde effectieve retourtype T .
• Anders kan een effectief retourtype niet worden afgeleid voor F.

Het afgeleide retourtype wordt als volgt bepaald:

• Als F asynchroon is en het lijf van F ofwel een expressie is geclassificeerd als niets (§12.2), ofwel een blok waarin geen return instructies expressies bevatten, is het afgeleide retourtype «TaskType» (§15.14.1).
• Als F asynchroon is en een afgeleid effectief retourtype T heeft, dan is het afgeleide retourtype «TaskType»<T>»(§15.14.1).
• Als F niet-asynchroon is en een afgeleid effectief retourtype Theeft, is het afgeleide retourtype T.
• Anders kan een retourtype niet worden afgeleid voor F.

voorbeeld: als voorbeeld van typedeductie waarbij anonieme functies betrokken zijn, kunt u de Select extensiemethode overwegen die is gedeclareerd in de klasse System.Linq.Enumerable:

namespace System.Linq
{
    public static class Enumerable
    {
        public static IEnumerable<TResult> Select<TSource,TResult>(
            this IEnumerable<TSource> source,
            Func<TSource,TResult> selector)
        {
            foreach (TSource element in source)
            {
                yield return selector(element);
            }
        }
   }
}

Ervan uitgaande dat de System.Linq naamruimte is geïmporteerd met een using namespace instructie, en gegeven een klasse Customer met een Name-eigenschap van type string, kan de Select-methode worden gebruikt om de namen van een lijst met klanten te selecteren:

List<Customer> customers = GetCustomerList();
IEnumerable<string> names = customers.Select(c => c.Name);

De aanroep van de extensiemethode (§12.8.10.3) van Select wordt verwerkt door de aanroep te herschrijven naar een statische methode-aanroep:

IEnumerable<string> names = Enumerable.Select(customers, c => c.Name);

Omdat typeargumenten niet expliciet zijn opgegeven, wordt typedeductie gebruikt om de typeargumenten af te stellen. Ten eerste is het argument van de klant gerelateerd aan de bronparameter, waardoor TSource moet worden Customer. Vervolgens wordt c met behulp van het hierboven beschreven deductieproces van het anonieme functietype het type Customergegeven, en wordt de expressie c.Name gerelateerd aan het retourtype van de selectieparameter, waarbij TResult wordt afgeleid als string. De aanroep is dus gelijk aan

Sequence.Select<Customer,string>(customers, (Customer c) => c.Name)

en het resultaat is van het type IEnumerable<string>.

In het volgende voorbeeld ziet u hoe deductie van anonieme functietypen het mogelijk maakt om typegegevens te 'stromen' tussen argumenten in een algemene methode-aanroep. Gegeven de volgende methode en aanroeping:

class A
{
    static Z F<X,Y,Z>(X value, Func<X,Y> f1, Func<Y,Z> f2)
    {
        return f2(f1(value));
    }

    static void M()
    {
        double hours = F("1:15:30", s => TimeSpan.Parse(s), t => t.TotalHours);
    }
}

typedeductie voor de aanroep gaat als volgt: Eerst is het argument "1:15:30" gerelateerd aan de waardeparameter, waardoor X moet worden string. Vervolgens krijgt de parameter van de eerste anonieme functie, s, het afgeleide type stringen is de expressie TimeSpan.Parse(s) gerelateerd aan het retourtype van f1, waardoor Y wordt geïnterpreteerd als System.TimeSpan. Ten slotte krijgt de parameter van de tweede anonieme functie, t, het uitgestelde type System.TimeSpanen de expressie t.TotalHours is gerelateerd aan het retourtype van f2, waardoor Z moet worden double. Het resultaat van de aanroep is dus van het type double.

einde voorbeeld

12.6.3.15 Typedeductie voor conversie van methodegroepen

Net als bij aanroepen van algemene methoden wordt typedeductie ook toegepast wanneer een methodegroep M met een algemene methode wordt geconverteerd naar een bepaald type gedelegeerde D (§10,8). Gegeven van een methode

Tₑ M<X₁...Xᵥ>(T₁ x₁ ... Tₑ xₑ)

en de methodegroep M wordt toegewezen aan het delegeertype D, is de taak van type-inferentie om typeargumenten te vinden S₁...Sᵥ, zodat de expressie:

M<S₁...Sᵥ>

wordt compatibel (§21.2) met D.

In tegenstelling tot het algoritme voor typedeductie voor algemene methode-aanroepen, zijn er in dit geval alleen argumenten typen, geen argument expressies. Er zijn met name geen anonieme functies en dus geen noodzaak voor meerdere fasen van deductie.

In plaats daarvan worden alle Xᵢ beschouwd als niet-vastgemaakte, en wordt een ondergrensinferentie gemaakt van elk argumenttype Uₑ van D naar het overeenkomstige parametertype van Tₑ. Als er voor geen van de Xᵢ limieten werden gevonden, mislukt type-inferentie. Anders worden alle Xᵢvastgezet aan overeenkomende Sᵢ, die het resultaat zijn van type-inferentie.

12.6.3.16 Het vinden van het beste algemene type van een set expressies

In sommige gevallen moet een gemeenschappelijk type worden afgeleid voor een set expressies. In het bijzonder worden de elementtypen van impliciet getypte matrices en de retourtypen van anonieme functies met blok lichamen op deze manier gevonden.

Het meest voorkomende type voor een set expressies E₁...Eᵥ wordt als volgt bepaald:

• Er wordt een nieuwe niet-vast typevariabele geïntroduceerd X.
• Voor elke expressie Ei wordt een deductie van het uitvoertype (§12.6.3.8) uitgevoerd naar X.
• X is opgelost (§12.6.3.13), indien mogelijk, en het resulterende type is het meest gangbare type.
• Anders mislukt inferentie.

Opmerking: Deze inferentie is intuïtief gelijk aan het aanroepen van een methode void M<X>(X x₁ ... X xᵥ) met de Eᵢ als argumenten en het afleiden van X. eindnotitie

12.6.4 Overbelastingsresolutie

12.6.4.1 Algemeen

Overbelastingsresolutie is een bindingstijdmechanisme voor het selecteren van het beste functielid om aan te roepen op basis van een lijst met argumenten en een reeks kandidaat-functieleden. Overbelastingsresolutie selecteert het functielid dat moet worden aangeroepen in de volgende afzonderlijke contexten binnen C#:

• Aanroep van een methode die is genoemd in een invocation_expression (§12.8.10).
• Aanroep van een instantieconstructor met de naam in een object_creation_expression (§12.8.17.2).
• Aanroep van een toegangsfunctie voor een indexeerfunctie via een element_access (§12.8.12).
• Aanroepen van een vooraf gedefinieerde of door de gebruiker gedefinieerde operator waarnaar wordt verwezen in een expressie (§12.4.4 en §12.4.5).

Elk van deze contexten definieert de set kandidaatfunctieleden en de lijst met argumenten op een eigen unieke manier. De set kandidaten voor een methode-aanroep bevat bijvoorbeeld geen methoden die zijn gemarkeerd als override (§12.5), en methoden in een basisklasse zijn geen kandidaten als een methode in een afgeleide klasse van toepassing is (§12.8.10.2).

Zodra de leden van de kandidaatfunctie en de argumentenlijst zijn geïdentificeerd, is de selectie van het beste functielid in alle gevallen hetzelfde:

• Ten eerste wordt de set kandidaatfunctieleden gereduceerd tot die functieleden die van toepassing zijn op de opgegeven argumentenlijst (§12.6.4.2). Als deze gereduceerde set leeg is, treedt er een compilatietijdfout op.
• Vervolgens bevindt het beste functielid uit de set van toepasselijke kandidaatfunctieleden zich. Als de set slechts één functielid bevat, is dat functielid het beste functielid. Anders is het beste functielid het ene functielid dat beter is dan alle andere functieleden met betrekking tot de opgegeven argumentenlijst, mits elk functielid wordt vergeleken met alle andere functieleden die gebruikmaken van de regels in §12.6.4.3. Als er niet precies één functielid is dat beter is dan alle andere functieleden, is de aanroep van het functielid niet eenduidig en treedt er een bindingstijdfout op.

De volgende subclauses definiëren de exacte betekenis van de termen toepasselijke functielid en beter functielid.

12.6.4.2 Toepasselijk functielid

Een functielid wordt geacht een van toepassing functielid te zijn met betrekking tot een lijst met argumenten A wanneer alle volgende waar zijn:

• Elk argument in A komt overeen met een parameter in de declaratie van het functielid, zoals beschreven in §12.6.2.2, ten hoogste één argument komt overeen met elke parameter en een parameter waarvoor geen argument overeenkomt, is een optionele parameter.
• Voor elk argument in Ais de parameterdoorgiftemodus van het argument identiek aan de parameterdoorgiftemodus van de bijbehorende parameter en
  • voor een waardeparameter of een parametermatrix bestaat een impliciete conversie (§10.2) van de argumentexpressie tot het type van de bijbehorende parameter, of
  • voor een verwijzings- of uitvoerparameter is er een identiteitsconversie tussen het type argumentexpressie (indien aanwezig) en het type van de bijbehorende parameter, of
  • voor een invoerparameter wanneer het bijbehorende argument de wijzigingsfunctie in heeft, is er een identiteitsconversie tussen het type van de argumentexpressie (indien van toepassing) en het type van de bijbehorende parameter, of
  • voor een invoerparameter wanneer het bijbehorende argument de in modifier weglaat, bestaat er een impliciete conversie (§10.2) van de argumentexpressie tot het type van de bijbehorende parameter.

Voor een functielid dat een parametermatrix bevat, als het functielid van toepassing is volgens de bovenstaande regels, wordt gezegd dat het van toepassing is in de normale vorm. Als een functielid dat een parametermatrix bevat, niet van toepassing is in de normale vorm, kan het functielid in plaats daarvan van toepassing zijn in de uitgevouwen vorm:

• Het uitgevouwen formulier wordt samengesteld door de parametermatrix in de functieliddeclaratie te vervangen door nul of meer waardeparameters van het elementtype van de parametermatrix, zodat het aantal argumenten in de argumentenlijst A overeenkomt met het totale aantal parameters. Als A minder argumenten heeft dan het aantal vaste parameters in de declaratie van het functielid, kan de uitgevouwen vorm van het functielid niet worden samengesteld en is dus niet van toepassing.
• Anders is het uitgevouwen formulier van toepassing als voor elk argument in Aeen van de volgende waar is:
  • de parameterdoorgiftemodus van het argument is identiek aan de parameterdoorgiftemodus van de bijbehorende parameter en:
    • voor een parameter met vaste waarde of een waardeparameter die door de uitbreiding is gemaakt, bestaat er een impliciete conversie (§10.2) van de argumentexpressie tot het type van de bijbehorende parameter; of
    • voor een by-reference-parameter is het type argumentexpressie identiek aan het type van de bijbehorende parameter.
  • de parameterdoorgiftemodus van het argument is waarde en de parameterdoorgiftemodus van de bijbehorende parameter is invoer en een impliciete conversie (§10.2) bestaat uit de argumentexpressie tot het type van de bijbehorende parameter.

Wanneer de impliciete conversie van het argumenttype naar het parametertype van een invoerparameter een dynamische impliciete conversie is (§10.2.10), zijn de resultaten niet gedefinieerd.

Voorbeeld: Gegeven de volgende declaraties en methodeaanroepen:

public static void M1(int p1) { ... }
public static void M1(in int p1) { ... }
public static void M2(in int p1) { ... }
public static void Test()
{
    int i = 10; uint ui = 34U;

    M1(in i);   // M1(in int) is applicable
    M1(in ui);  // no exact type match, so M1(in int) is not applicable
    M1(i);      // M1(int) and M1(in int) are applicable
    M1(i + 5);  // M1(int) and M1(in int) are applicable
    M1(100u);   // no implicit conversion exists, so M1(int) is not applicable

    M2(in i);   // M2(in int) is applicable
    M2(i);      // M2(in int) is applicable
    M2(i + 5);  // M2(in int) is applicable
}

einde voorbeeld

• Een statische methode is alleen van toepassing als de methodegroep het resultaat is van een simple_name of een member_access via een type.
• Een instantiemethode is alleen van toepassing als de methodegroep het resultaat is van een simple_name, een member_access via een variabele of waarde of een base_access.
  • Als de methodegroep het resultaat is van een simple_name, is een instantiemethode alleen van toepassing als this toegang is toegestaan §12.8.14.
• Wanneer de methodegroep het resultaat is van een member_access die kan worden gebruikt via een exemplaar of een type zoals beschreven in §12.8.7.2, zijn zowel exemplaar- als statische methoden van toepassing.
• Een algemene methode waarvan de typeargumenten (expliciet opgegeven of afgeleid) niet aan hun beperkingen voldoen, is niet van toepassing.
• In de context van een methodegroepconversie bestaat er een identiteitsconversie (§10.2.2) of een impliciete verwijzingsconversie (§10.2.8) van het retourtype van de methode naar het retourtype van de gemachtigde. Anders is de kandidaatmethode niet van toepassing.

12.6.4.3 Beter functielid

Voor het bepalen van het betere functielid wordt een lijst met gestreepte argumenten A samengesteld die alleen de argumentexpressies zelf bevat in de volgorde waarin ze worden weergegeven in de oorspronkelijke lijst met argumenten en eventuele out of ref argumenten weglaat.

Parameterslijsten voor elk van de kandidaatfunctieleden worden op de volgende manier samengesteld:

• Het uitgevouwen formulier wordt gebruikt als het functielid alleen van toepassing was in het uitgevouwen formulier.
• Optionele parameters zonder bijbehorende argumenten worden verwijderd uit de lijst met parameters
• Verwijzings- en uitvoerparameters worden verwijderd uit de lijst met parameters
• De parameters worden opnieuw gerangschikt, zodat ze zich op dezelfde positie bevinden als het bijbehorende argument in de lijst met argumenten.

Gezien een lijst met argumenten A met een set argumentexpressies {E₁, E₂, ..., Eᵥ} en twee toepasselijke functieleden Mᵥ en Mₓ met parametertypen {P₁, P₂, ..., Pᵥ} en {Q₁, Q₂, ..., Qᵥ}, wordt Mᵥ gedefinieerd als een beter functielid dan Mₓ als

• voor elk argument is de impliciete conversie van Eᵥ naar Qᵥ niet beter dan de impliciete conversie van Eᵥ naar Pᵥ, en
• voor ten minste één argument is de conversie van Eᵥ naar Pᵥ beter dan de conversie van Eᵥ naar Qᵥ.

Als de parametertypereeksen {P₁, P₂, ..., Pᵥ} en {Q₁, Q₂, ..., Qᵥ} gelijkwaardig zijn (dat wil bijvoorbeeld dat elke Pᵢ een identiteitsconversie heeft naar de bijbehorende Qᵢ), worden de volgende regels voor tie-breaking toegepast om het betere lid van de functie te bepalen.

• Als Mᵢ een niet-generieke methode is en Mₑ een algemene methode is, is Mᵢ beter dan Mₑ.
• Als Mᵢ in de normale vorm van toepassing is en Mₑ een parametermatrix heeft en alleen van toepassing is in de uitgevouwen vorm, is Mᵢ beter dan Mₑ.
• Als beide methoden parametermatrices hebben en alleen van toepassing zijn in hun uitgevouwen vormen en als de parametermatrix van Mᵢ minder elementen heeft dan de parametermatrix van Mₑ, is Mᵢ beter dan Mₑ.
• Als Mᵥ meer specifieke parametertypen heeft dan Mₓ, is Mᵥ beter dan Mₓ. Laat {R1, R2, ..., Rn} en {S1, S2, ..., Sn} de niet-geïnstantieerde en niet-uitgevouwen parametertypen van Mᵥ en Mₓvoorstellen. Mᵥparametertypen zijn specifieker dan Mₓs als voor elke parameter Rx niet minder specifiek is dan Sx, en voor ten minste één parameter is Rx specifieker dan Sx:
  • Een typeparameter is minder specifiek dan een niet-typeparameter.
  • Recursief is een samengesteld type specifieker dan een ander samengesteld type (met hetzelfde aantal typeargumenten) als ten minste één typeargument specifieker is en geen typeargument minder specifiek is dan het bijbehorende typeargument in het andere.
  • Een matrixtype is specifieker dan een ander matrixtype (met hetzelfde aantal dimensies) als het elementtype van de eerste specifieker is dan het elementtype van de tweede.
• Anders geldt dat als één lid een niet-gelifte operator is en de andere een gelifte operator, de niet-gelifte beter is.
• Als geen van beide functieleden beter is gebleken en alle parameters van Mᵥ een corresponderend argument hebben, terwijl standaardargumenten moeten worden vervangen door ten minste één optionele parameter in Mₓ, is Mᵥ beter dan Mₓ.
• Als voor ten minste één parameter Mᵥ de betere keuze voor het doorgeven van parameters gebruikt (§12.6.4.4) dan de bijbehorende parameter in Mₓ en geen van de parameters in Mₓ de betere keuze voor parameterdoorgifte dan Mᵥ, is Mᵥ beter dan Mₓ.
• Anders is geen functielid beter.

12.6.4.4 Betere parameter-doorvoermethode

Het is toegestaan om overeenkomstige parameters in twee overbelaste methoden alleen te laten verschillen door de parameterdoorgiftemodus op voorwaarde dat een van de twee parameters de modus voor het doorgeven van waarden heeft, als volgt:

public static void M1(int p1) { ... }
public static void M1(in int p1) { ... }

Gezien int i = 10;, volgens §12.6.4.2, leiden de aanroepen M1(i) en M1(i + 5) ertoe dat beide overbelastingen van toepassing zijn. In dergelijke gevallen is de methode met de parameterdoorgiftelmodus op basis van waarden de betere keuze voor de doorgiftemodus voor parameters.

Opmerking: er is geen keuze nodig voor argumenten van invoer-, uitvoer- of verwijzingsmodi, omdat deze argumenten alleen overeenkomen met exact dezelfde parameterdoorgiftemodi. eindnotitie

12.6.4.5 Betere conversie van expressie

Gezien een impliciete conversie C₁ die wordt geconverteerd van een expressie E naar een type T₁en een impliciete conversie C₂ die converteert van een expressie E naar een type T₂, is C₁ een betere conversie dan C₂ als een van de volgende bewaringen geldt:

• E exact overeenkomt met T₁ en E komt niet exact overeen met T₂ (§12.6.4.6)
• E komt exact overeen met zowel T₁ als T₂, en T₁ is een beter conversiedoel dan T₂ (§12.6.4.7)
• E is een methodegroep (§12.2), T₁ is compatibel (§21.4) met de beste methode uit de methodegroep voor conversie C₁en T₂ is niet compatibel met de beste methode uit de methodegroep voor conversie C₂

12.6.4.6 Exact overeenkomende expressie

Gezien een expressie E en een type T, komt Eexact overeen metT als een van de volgende waarden geldt:

• E heeft een type Sen er bestaat een identiteitsconversie van S tot T
• E is een anonieme functie, T is een delegaat type D of een expressieboomtype Expression<D> en geldt een van de volgende:
  • Er bestaat een afgeleid retourtype X voor E in de context van de parameterlijst van D (§12.6.3.13) en er bestaat een identiteitsconversie van X het retourtype D
  • E is een async lambda zonder retourwaarde, en D heeft een retourtype dat een niet-generieke «TaskType» is
  • E is niet asynchroon en D heeft een retourtype Y, of E is asynchroon en D heeft een retourtype «TaskType»<Y>(§15.14.1), en een van de volgende is van toepassing:
    • De hoofdtekst van E is een expressie die exact overeenkomt met Y
    • De hoofdtekst van E is een blok waarin elke retourinstructie een expressie retourneert die exact overeenkomt met Y

12.6.4.7 Beter conversiedoelstelling

Voor de twee typen T₁ en T₂is T₁ een beter conversiedoel dan T₂ als een van de volgende voorwaarden geldt:

• Er bestaat een impliciete conversie van T₁ naar T₂ en er bestaat geen impliciete conversie van T₂ naar T₁
• T₁ is «TaskType»<S₁>(§15.14.1), T₂ is «TaskType»<S₂>, en is S₁ een beter conversiedoel dan S₂
• T₁ is «TaskType»<S₁>(§15.14.1), T₂ is «TaskType»<S₂>en T₁ is meer gespecialiseerd dan T₂
• T₁ is S₁ of S₁? waarbij S₁ een ondertekend integraal type is en T₂ is S₂ of S₂? waarbij S₂ een niet-ondertekend integraaltype is. Specifiek:
  • S₁ is sbyte en S₂ is byte, ushort, uint, of ulong
  • S₁ is short en S₂ is ushort, uint, of ulong
  • S₁ is int en S₂ is uintofwel ulong
  • S₁ is long en S₂ is ulong

12.6.4.8 Overloading in algemene klassen

Opmerking: hoewel handtekeningen zoals aangegeven uniek zijn (§8.6), is het mogelijk dat vervanging van typeargumenten identieke handtekeningen oplevert. In een dergelijke situatie kiest overbelastingsoplossing de meest specifieke (§12.6.4.3) van de oorspronkelijke handtekeningen (vóór vervanging van typeargumenten), als deze bestaat en meldt anders een fout. eindnotitie

voorbeeld: in de volgende voorbeelden ziet u overbelastingen die geldig en ongeldig zijn volgens deze regel:

public interface I1<T> { ... }
public interface I2<T> { ... }

public abstract class G1<U>
{
    public abstract int F1(U u);           // Overload resolution for G<int>.F1
    public abstract int F1(int i);         // will pick non-generic

    public abstract void F2(I1<U> a);      // Valid overload
    public abstract void F2(I2<U> a);
}

abstract class G2<U,V>
{
    public abstract void F3(U u, V v);     // Valid, but overload resolution for
    public abstract void F3(V v, U u);     // G2<int,int>.F3 will fail

    public abstract void F4(U u, I1<V> v); // Valid, but overload resolution for
    public abstract void F4(I1<V> v, U u); // G2<I1<int>,int>.F4 will fail

    public abstract void F5(U u1, I1<V> v2);   // Valid overload
    public abstract void F5(V v1, U u2);

    public abstract void F6(ref U u);      // Valid overload
    public abstract void F6(out V v);
}

einde voorbeeld

12.6.5 Compileertijdcontrole van dynamische aanroep van leden

Hoewel overbelastingsresolutie van een dynamisch gebonden bewerking plaatsvindt tijdens runtime, is het soms mogelijk om tijdens het compileren de lijst met functieleden te kennen waaruit een overbelasting wordt gekozen:

• Voor een delegatie-aanroep (§12.8.10.4) is de lijst een enkel functielid met dezelfde parameterlijst als die van de delegate_type van de aanroep.
• Voor een methodeaanroep (§12.8.10.2) op een type of op een waarde waarvan het statische type niet dynamisch is, is de set toegankelijke methoden in de methodegroep bekend tijdens het compileren.
• Voor een expressie voor het maken van objecten (§12.8.17.2) is de set toegankelijke constructors in het type bekend tijdens het compileren.
• Voor toegang tot een indexeerfunctie (§12.8.12.4) is de set toegankelijke indexeerfuncties in de ontvanger bekend tijdens het compileren.

In deze gevallen wordt er een beperkte compilatietijdcontrole uitgevoerd op elk lid van de bekende set functieleden, om te zien of er met zekerheid kan worden vastgesteld dat deze nooit tijdens de uitvoeringstijd wordt aangeroepen. Voor elk functielid F een gewijzigde parameter en lijst met argumenten zijn samengesteld:

• Als F een algemene methode en typeargumenten zijn opgegeven, worden deze eerst vervangen door de typeparameters in de parameterlijst. Als er echter geen typeargumenten zijn opgegeven, vindt er geen vervanging plaats.
• Vervolgens wordt elke parameter waarvan het type is geopend (dat wil bijvoorbeeld een typeparameter bevatten; zie §8.4.3) wordt verwijderd, samen met de bijbehorende argumenten.

Voor F om de controle te doorstaan, moeten alle volgende voorwaarden gelden:

• De gewijzigde parameterlijst voor F is van toepassing op de lijst met gewijzigde argumenten in termen van §12.6.4.2.
• Alle samengestelde typen in de gewijzigde parameterlijst voldoen aan hun beperkingen (§8.4.5).
• Als de typeparameters van F in de bovenstaande stap zijn vervangen, worden aan hun beperkingen voldaan.
• Als F een statische methode is, mag de methodegroep niet ontstaan uit een member_access waarvan tijdens het compileren bekend is dat de ontvanger een variabele of waarde is.
• Als F een instantiemethode is, heeft de methodegroep niet geresulteerd uit een member_access waarvan de ontvanger op het moment van compileren bekend is dat het een type is.

Als er geen kandidaat aan deze test is geslaagd, treedt er een compilatiefout op.

12.6.6 Functielid aanroepen

12.6.6.1 Algemeen

In dit subclause wordt het proces beschreven dat tijdens de uitvoering plaatsvindt om een bepaald functielid aan te roepen. Er wordt vanuit gegaan dat een bindingstijdproces al heeft bepaald dat het specifieke lid moet worden aangeroepen, mogelijk door overbelastingsresolutie toe te passen op een set kandidaatfunctieleden.

Voor het beschrijven van het aanroepproces worden functieleden onderverdeeld in twee categorieën:

• Statische functieleden. Dit zijn statische methoden, statische eigenschapstoegangsors en door de gebruiker gedefinieerde operators. Statische functieleden zijn altijd niet-virtueel.
• Instantiefunctieleden. Dit zijn instantiemethoden, instantieconstructors, instantie-eigenschapstoegangsmethoden en indexeertoevallers. Functieleden van een instantie zijn niet-virtueel of virtueel en worden altijd aangeroepen op een specifiek exemplaar. Het exemplaar wordt berekend door een exemplaarexpressie en wordt toegankelijk binnen het functielid als this (§12.8.14). Voor een exemplaarconstructor wordt de exemplaarexpressie beschouwd als het zojuist toegewezen object.

De uitvoering van een aanroep van een functielid bestaat uit de volgende stappen, waarbij M het functielid is en, als M een exemplaarlid is, E de exemplaarexpressie is:

• Als M een statisch functielid is:
  • De lijst met argumenten wordt geëvalueerd zoals beschreven in §12.6.2.
  • M wordt aangeroepen.
• Als het type E een waardetype Vis en M wordt gedeclareerd of overschreven in V:
  • E wordt geëvalueerd. Als deze evaluatie een uitzondering veroorzaakt, worden er geen verdere stappen uitgevoerd. Voor een instantieconstructor bestaat deze evaluatie uit het toewijzen van opslag (meestal uit een uitvoeringsstack) voor het nieuwe object. In dit geval wordt E geclassificeerd als een variabele.
  • Als E niet wordt geclassificeerd als een variabele, of als V het geen alleen-lezen structtype (§16.2.2) is en M geen alleen-lezen functielid is (§16.4.12), en E een van:
    • een invoerparameter (§15.6.2.3.2) of
    • een readonly veld (§15.5.3), of
    • een readonly referentievariabele of retournering (§9.7), wordt vervolgens een tijdelijke lokale variabele van Ehet type gemaakt en wordt de waarde toegewezen E aan die variabele. E wordt vervolgens opnieuw geclassificeerd als een verwijzing naar die tijdelijke lokale variabele. De tijdelijke variabele is toegankelijk als this binnen M, maar niet op een andere manier. Dus alleen wanneer E kan worden geschreven, kan de beller de wijzigingen observeren die M aan thisaanbrengt.
  • De lijst met argumenten wordt geëvalueerd zoals beschreven in §12.6.2.
  • M wordt aangeroepen. De variabele waarnaar wordt verwezen door E wordt de variabele waarnaar wordt verwezen door this.
• Anders:
  • E wordt geëvalueerd. Als deze evaluatie een uitzondering veroorzaakt, worden er geen verdere stappen uitgevoerd.
  • De lijst met argumenten wordt geëvalueerd zoals beschreven in §12.6.2.
  • Als het type E een value_typeis, wordt een boxing-conversie (§10.2.9) uitgevoerd om E te converteren naar een class_type, en wordt E in de volgende stappen als die class_type beschouwd. Als het value_type een enum_type is, is de class_typeSystem.Enum;; anders is deze System.ValueType.
  • De waarde van E is gecontroleerd op geldigheid. Als de waarde van E null is, wordt er een System.NullReferenceException gegenereerd en worden er geen verdere stappen uitgevoerd.
  • De implementatie van het functielid dat moet worden aangeroepen, wordt bepaald:
    • Als het binding-time type van E een interface is, is het functielid dat moet worden aangeroepen de implementatie van M geleverd door het runtime-type van de instantie waar Enaar verwijst. Dit functielid wordt bepaald door de interfacetoewijzingsregels (§19.6.5) toe te passen om de implementatie te bepalen van M het uitvoeringstype van het exemplaar waarnaar wordt verwezen door E.
    • Anders, als M een virtueel functielid is, dan is het functielid dat aangeroepen moet worden de implementatie van M, geleverd door het uitvoeringstype van het exemplaar waarnaar Everwijst. Dit functielid wordt bepaald door de regels toe te passen voor het bepalen van de meest afgeleide implementatie (§15.6.4) van M met betrekking tot het uitvoeringstype van het exemplaar waarnaar wordt verwezen door E.
    • Anders is M het niet-virtuele functielid en is het functielid dat moet worden aangeroepen M zelf.
  • De implementatie van het functielid die in de bovenstaande stap is bepaald, wordt aangeroepen. Het object waarnaar wordt verwezen door E wordt het object waarnaar door dit wordt verwezen.

Opmerking:§12.2 classificeert de toegang tot eigenschappen als het aanroepen van het bijbehorende functielid, ofwel de get accessor of de set toegangsfunctie. Het bovenstaande proces wordt gevolgd voor het aanroepen van die accessor. eindnotitie

Het resultaat van de aanroep van een instantieconstructor (§12.8.17.2) is de waarde die is gemaakt. Het resultaat van de aanroep van een ander functielid is de eventueel geretourneerde waarde (§13.10.5) uit het lichaam.

12.6.6.2 Aanroepen op gewrapte instanties

Een functielid dat is geïmplementeerd in een value_type kan worden aangeroepen door middel van een omgezet exemplaar van die value_type in de volgende situaties:

• Wanneer het functielid een overriding is van een methode die is geërfd van het class_type en wordt aangeroepen via een instance expressie van dat class_type.

  Opmerking: de class_type is altijd een van System.Object, System.ValueType of System.Enum.  eindnotitie

• Wanneer het functielid een implementatie is van een interfacefunctielid en wordt aangeroepen via een exemplaarexpressie van een interface_type.
• Wanneer het functielid wordt aangeroepen via een gemachtigde.

In deze situaties wordt het boxed-exemplaar beschouwd als een variabele van het type value_type, en deze variabele wordt de variabele waarnaar wordt verwezen binnen de aanroep van het functielid.

Opmerking: dit betekent met name dat wanneer een functielid wordt aangeroepen op een boxed exemplaar, het mogelijk is dat het functielid de waarde in het boxed-exemplaar wijzigt. eindnotitie

12.7 Deconstructie

Deconstructie is een proces waarbij een expressie wordt omgezet in een tuple van afzonderlijke expressies. Deconstructie wordt gebruikt wanneer het doel van een eenvoudige toewijzing een tuple-expressie is, om waarden te verkrijgen die aan de elementen van die tuple moeten worden toegekend.

Een expressie E wordt gedeconstrueerd tot een tuple-expressie met n elementen op de volgende manier:

• Als E een tuple-expressie is met n elementen, is het resultaat van de deconstructie de expressie E zichzelf.
• Anders, als E een tupletype (T1, ..., Tn) met n elementen heeft, dan wordt E geëvalueerd in een tijdelijke variabele __ven is het resultaat van de deconstructie de expressie (__v.Item1, ..., __v.Itemn).
• Als de expressie E.Deconstruct(out var __v1, ..., out var __vn) tijdens het compileren wordt omgezet in een unieke instantie of extensiemethode, wordt die expressie geëvalueerd en is het resultaat van de deconstructie de expressie (__v1, ..., __vn). Een dergelijke methode wordt een deconstructorgenoemd.
• Anders kan E niet worden gedeconstrueerd.

Hier verwijzen __v en __v1, ..., __vn naar onzichtbare en ontoegankelijke tijdelijke variabelen.

Opmerking: een expressie van het type dynamic kan niet worden gedeconstrueerd. eindnotitie

12.8 Primaire expressies

12.8.1 Algemeen

Primaire expressies bevatten de eenvoudigste vormen van expressies.

primary_expression
    : literal
    | interpolated_string_expression
    | simple_name
    | parenthesized_expression
    | tuple_expression
    | member_access
    | null_conditional_member_access
    | invocation_expression
    | element_access
    | null_conditional_element_access
    | this_access
    | base_access
    | post_increment_expression
    | post_decrement_expression
    | null_forgiving_expression
    | array_creation_expression
    | object_creation_expression
    | delegate_creation_expression
    | anonymous_object_creation_expression
    | typeof_expression
    | sizeof_expression
    | checked_expression
    | unchecked_expression
    | default_value_expression
    | nameof_expression    
    | anonymous_method_expression
    | pointer_member_access     // unsafe code support
    | pointer_element_access    // unsafe code support
    | stackalloc_expression
    ;

Opmerking: deze grammaticaregel is niet gereed voor ANTLR omdat deze deel uitmaakt van een reeks wederzijds recursieve regels (primary_expression, member_access, invocation_expressionelement_access, , post_increment_expression, , post_decrement_expression, en null_forgiving_expressionpointer_member_accesspointer_element_access) die ANTLR niet verwerkt. Standaardtechnieken kunnen worden gebruikt om de grammatica te transformeren en de wederzijdse linker recursie te verwijderen. Deze standaard doet dit niet omdat niet alle parseringsstrategieën dit vereisen (bijvoorbeeld een LALR-parser niet) en dit zou de structuur en beschrijving verdoezelen. eindnotitie

pointer_member_access (§24.6.3) en pointer_element_access (§24.6.4) zijn alleen beschikbaar in onveilige code (§24).

12.8.2 Letterlijke tekens

Een primary_expression die bestaat uit een letterlijke (§6.4,5) wordt geclassificeerd als een waarde.

12.8.3 Geïnterpoleerde tekenreeksexpressies

Een interpolated_string_expression bestaat uit $, $@of @$, direct gevolgd door tekst binnen " tekens. Binnen de tekst tussen aanhalingstekens zijn er nul of meer interpolaties, begrensd door de tekens { en }, die elk een expressie en optionele opmaakspecificaties bevatten.

Geïnterpoleerde tekenreeksexpressies hebben twee vormen; regular (interpolated_regular_string_expression) en verbatim (interpolated_verbatim_string_expression); die lexisch vergelijkbaar zijn met, maar semantisch verschillen van, de twee vormen van letterlijke tekenreeksen (§6.4.5.6).

interpolated_string_expression
    : interpolated_regular_string_expression
    | interpolated_verbatim_string_expression
    ;

// interpolated regular string expressions

interpolated_regular_string_expression
    : Interpolated_Regular_String_Start Interpolated_Regular_String_Mid?
      ('{' regular_interpolation '}' Interpolated_Regular_String_Mid?)*
      Interpolated_Regular_String_End
    ;

regular_interpolation
    : expression (',' interpolation_minimum_width)?
      Regular_Interpolation_Format?
    ;

interpolation_minimum_width
    : constant_expression
    ;

Interpolated_Regular_String_Start
    : '$"'
    ;

// the following three lexical rules are context sensitive, see details below

Interpolated_Regular_String_Mid
    : Interpolated_Regular_String_Element+
    ;

Regular_Interpolation_Format
    : ':' Interpolated_Regular_String_Element+
    ;

Interpolated_Regular_String_End
    : '"'
    ;

fragment Interpolated_Regular_String_Element
    : Interpolated_Regular_String_Character
    | Simple_Escape_Sequence
    | Hexadecimal_Escape_Sequence
    | Unicode_Escape_Sequence
    | Open_Brace_Escape_Sequence
    | Close_Brace_Escape_Sequence
    ;

fragment Interpolated_Regular_String_Character
    // Any character except " (U+0022), \\ (U+005C),
    // { (U+007B), } (U+007D), and New_Line_Character.
    : ~["\\{}\u000D\u000A\u0085\u2028\u2029]
    ;

// interpolated verbatim string expressions

interpolated_verbatim_string_expression
    : Interpolated_Verbatim_String_Start Interpolated_Verbatim_String_Mid?
      ('{' verbatim_interpolation '}' Interpolated_Verbatim_String_Mid?)*
      Interpolated_Verbatim_String_End
    ;

verbatim_interpolation
    : expression (',' interpolation_minimum_width)?
      Verbatim_Interpolation_Format?
    ;

Interpolated_Verbatim_String_Start
    : '$@"'
    | '@$"'
    ;

// the following three lexical rules are context sensitive, see details below

Interpolated_Verbatim_String_Mid
    : Interpolated_Verbatim_String_Element+
    ;

Verbatim_Interpolation_Format
    : ':' Interpolated_Verbatim_String_Element+
    ;

Interpolated_Verbatim_String_End
    : '"'
    ;

fragment Interpolated_Verbatim_String_Element
    : Interpolated_Verbatim_String_Character
    | Quote_Escape_Sequence
    | Open_Brace_Escape_Sequence
    | Close_Brace_Escape_Sequence
    ;

fragment Interpolated_Verbatim_String_Character
    : ~["{}]    // Any character except " (U+0022), { (U+007B) and } (U+007D)
    ;

// lexical fragments used by both regular and verbatim interpolated strings

fragment Open_Brace_Escape_Sequence
    : '{{'
    ;

fragment Close_Brace_Escape_Sequence
    : '}}'
    ;

Zes van de hierboven gedefinieerde lexicale regels zijn als volgt contextgevoelige:

Opmerking: de bovenstaande regels zijn contextgevoelig omdat de definities overlappen met die van andere tokens in de taal. eindnotitie

Opmerking: de bovenstaande grammatica is niet gereed voor ANTLR vanwege de contextgevoelige lexicale regels. Net als bij andere lexergenerators ondersteunt ANTLR contextgevoelige lexicale regels, bijvoorbeeld met behulp van de lexicale modi, maar dit is een implementatiedetail en daarom geen deel van deze specificatie. eindnotitie

Een interpolated_string_expression wordt geclassificeerd als een waarde. Als deze direct wordt geconverteerd naar System.IFormattable of System.FormattableString met een impliciete geïnterpoleerde tekenreeksconversie (§10.2.5), heeft de geïnterpoleerde tekenreeksexpressie dat type. Anders is het van het type string.

Opmerking: de verschillen tussen de mogelijke typen een interpolated_string_expression kunnen worden bepaald uit de documentatie voor System.String (§C.2) en System.FormattableString (§C.3). eindnotitie

De betekenis van een interpolatie, zowel regular_interpolation als verbatim_interpolation, is het opmaken van de waarde van de expressie als een string volgens de indeling die is opgegeven door de Regular_Interpolation_Format of Verbatim_Interpolation_Format, of volgens een standaardindeling voor het type expressie. De opgemaakte tekenreeks wordt vervolgens gewijzigd door de interpolation_minimum_width, indien van toepassing, om de definitieve string te creëren die in de interpolated_string_expressionwordt geïnterpoleerd.

Opmerking: hoe de standaardindeling voor een type wordt bepaald, wordt beschreven in de documentatie voor System.String (§C.2) en System.FormattableString (§C.3). Beschrijvingen van standaardindelingen, die identiek zijn voor Regular_Interpolation_Format en Verbatim_Interpolation_Format, vindt u in de documentatie voor System.IFormattable (§C.4) en in andere typen in de standaardbibliotheek (§C). eindnotitie

In een interpolation_minimum_width heeft de constant_expression een impliciete conversie naar int. Laat de veldbreedte de absolute waarde van deze constante expressie zijn en laat de uitlijning overeenkomen met het teken (positief of negatief) van de waarde van deze constante expressie:

• Als de waarde van de veldbreedte kleiner is dan of gelijk is aan de lengte van de opgemaakte tekenreeks, wordt de opgemaakte tekenreeks niet gewijzigd.
• Anders wordt de opgemaakte tekenreeks opgevuld met spatietekens, zodat de lengte gelijk is aan de veldbreedte:
  • Als de uitlijning positief is, wordt de opgemaakte tekenreeks rechts uitgelijnd door de opvulling aan te passen,
  • Anders wordt het links uitgelijnd door opvulling toe te voegen.

De algemene betekenis van een interpolated_string_expression, inclusief de bovenstaande opmaak en opvulling van interpolaties, wordt gedefinieerd door een conversie van de expressie naar een methodeaanroep: als het type expressie wordt System.IFormattable of System.FormattableString die methode is System.Runtime.CompilerServices.FormattableStringFactory.Create (§C.3) die een waarde van het type System.FormattableStringretourneert ; anders wordt het type string en wordt de methode string.Format (§C.2) die een waarde van het type stringretourneert .

In beide gevallen bestaat de argumentenlijst van de aanroep uit een opmaakreeksletterlijke met opmaakspecificaties voor elke interpolatie en een argument voor elke expressie die overeenkomt met de opmaakspecificaties.

De letterlijke notatietekenreeks wordt als volgt samengesteld, waarbij N het aantal interpolaties is in de interpolated_string_expression . De letterlijke notatietekenreeks bestaat uit, in volgorde:

• De tekens van de Interpolated_Regular_String_Start of Interpolated_Verbatim_String_Start
• De tekens van de Interpolated_Regular_String_Mid of Interpolated_Verbatim_String_Mid, indien aanwezig.
• Als N ≥ 1 voor elk getal I van 0 tot N-1.
  • Een tijdelijke aanduidingsspecificatie:
    • Een linker accolade ({) teken
    • De decimale weergave van I
    • Als de bijbehorende regular_interpolation of verbatim_interpolation vervolgens een interpolation_minimum_widthheeft, wordt er een komma (,) gevolgd door de decimale weergave van de waarde van de constant_expression
    • De tekens van het Regular_Interpolation_Format of Verbatim_Interpolation_Format, indien van toepassing, van de bijbehorende regular_interpolation of verbatim_interpolation
    • Een rechter accolade (}) karakter
  • De tekens van de Interpolated_Regular_String_Mid of Interpolated_Verbatim_String_Mid die onmiddellijk na de bijbehorende interpolatie komen, indien van toepassing
• Ten slotte zijn dit de tekens van de Interpolated_Regular_String_End of Interpolated_Verbatim_String_End.

De volgende argumenten zijn de expressies uit de interpolaties, indien van toepassing, in volgorde.

Wanneer een interpolated_string_expression meerdere interpolaties bevat, worden de expressies in deze interpolaties geëvalueerd in tekstvolgorde van links naar rechts.

voorbeeld van:

In dit voorbeeld worden de volgende formatspecificaties gebruikt:

• de X-indelingsspecificatie waarmee gehele getallen als hoofdletter-hexadecimaal worden opgemaakt,
• de standaardindeling voor een string waarde is de waarde zelf,
• positieve uitlijningswaarden die rechts uitlijnen binnen de opgegeven minimale veldbreedte,
• negatieve uitlijningswaarden die links uitlijnen binnen de opgegeven minimale veldbreedte,
• gedefinieerde constanten voor de interpolation_minimum_widthen
• dat {{ en }} respectievelijk zijn opgemaakt als { en }.

Gegeven:

string text = "red";
int number = 14;
const int width = -4;

Dan:

einde voorbeeld

12.8.4 Eenvoudige namen

Een simple_name bestaat uit een id, eventueel gevolgd door een lijst met typeargumenten:

simple_name
    : identifier type_argument_list?
    ;

Een simple_name heeft de vorm I of de vorm I<A₁, ..., Aₑ>, waarbij I een enkele identificator is en I<A₁, ..., Aₑ> een optionele type-argumentenlijstis. Als er geen type_argument_list is opgegeven, wordt e als nul beschouwd. De simple_name wordt als volgt geëvalueerd en geclassificeerd:

• Als e nul is en de simple_name wordt weergegeven in een lokale ruimte voor variabeledeclaratie (§7.3) die rechtstreeks een lokale variabele, parameter of constante met naam Ibevat, verwijst de simple_name naar die lokale variabele, parameter of constante en wordt geclassificeerd als een variabele of waarde.
• Als e nul is en de simple_name wordt weergegeven in een algemene methodedeclaratie, maar buiten de kenmerken van de method_declaration, en als die declaratie een typeparameter met de naam Ibevat, verwijst de simple_name naar die typeparameter.
• Anders geldt voor elk exemplaartype T (§15.3.2), te beginnen met het exemplaartype van de onmiddellijk insluitende typedeclaratie en door te gaan met het exemplaartype van elke insluitende klasse- of structdeclaratie (indien van toepassing):
  • Als e nul is en de declaratie van T een typeparameter met de naam Ibevat, verwijst de simple_name naar die typeparameter.
  • Anders, als een ledenopzoeking (§12,5) van I in T met e typeargumenten een overeenkomst oplevert:
    • Als T het exemplaartype is van het onmiddellijk ingesloten klasse- of structtype en de zoekactie een of meer methoden identificeert, is het resultaat een methodegroep met een bijbehorende exemplaarexpressie van this. Als een lijst met typeargumenten is opgegeven, wordt deze gebruikt bij het aanroepen van een algemene methode (§12.8.10.2).
    • Als T het exemplaartype is van de onmiddellijk insluitende klasse of struct, als het zoeken een exemplaarlid identificeert en als de verwijzing optreedt in het blok van een exemplaarconstructor, een instantievemethode of een instantietoegangsmethode (§12.2.1), is het resultaat hetzelfde als een lidtoegang (§12.8.7) van de vorm this.I. Dit kan alleen gebeuren wanneer e nul is.
    • Anders is het resultaat hetzelfde als een toegang voor leden (§12.8.7) van de vorm T.I of T.I<A₁, ..., Aₑ>.
• Anders worden voor elke naamruimte N, beginnend met de naamruimte waarin de eenvoudige naam voorkomt, door te gaan met elke insluitende naamruimte (indien van toepassing) en eindigend met de globale naamruimte, worden de volgende stappen geëvalueerd totdat een entiteit is gevonden.
  • Als e nul is en I de naam van een naamruimte in Nis, dan:
    • Als de locatie waar de simple_name plaatsvindt, wordt ingesloten door een naamruimtedeclaratie voor N en de naamruimtedeclaratie een extern_alias_directive of using_alias_directive bevat die de naam I koppelt aan een naamruimte of type, is de simple_name niet eenduidig en treedt er een compilatietijdfout op.
    • Anders verwijst de simple_name naar de naamruimte met de naam I in N.
  • Anders, als N een toegankelijk type bevat met de naam I en typeparameters voor e, dan:
    • Als e nul is en de locatie waar de simple_name plaatsvindt, wordt ingesloten door een naamruimtedeclaratie voor N en bevat de naamruimtedeclaratie een extern_alias_directive of using_alias_directive die de naam I koppelt aan een naamruimte of type, is de simple_name dubbelzinnig en treedt er een compilatietijdfout op.
    • Anders verwijst de namespace_or_type_name naar het type dat is samengesteld met de opgegeven typeargumenten.
  • Anders, als de locatie waar de simple_name plaatsvindt, wordt ingesloten door een naamruimtedeclaratie voor N:
    • Als e nul is en de naamruimtedeclaratie een extern_alias_directive of using_alias_directive bevat die de naam I koppelt aan een geïmporteerde naamruimte of -type, verwijst de simple_name naar die naamruimte of dat type.
    • Anders, als de naamruimten die door de using_namespace_directives van de declaratie van de naamruimte zijn geïmporteerd, precies één type bevatten met de naam I en e type parameters, verwijst de simple_name naar dat type gevormd met de gespecificeerde typeargumenten.
    • Als de naamruimten die zijn geïmporteerd door de using_namespace_directives van de naamruimtedeclaratie meer dan één type bevatten met de naam I en e typeparameters, is de simple_name niet eenduidig en treedt er een compilatiefout op.

  Opmerking: deze hele stap is exact parallel aan de bijbehorende stap in de verwerking van een namespace_or_type_name (§7.8). eindnotitie

• Als dit e niet het getal is en I de id _is, is de simple_name een eenvoudige verwijdering, een vorm van declaratie-expressie (§12.19).
• Anders is de simple_name niet gedefinieerd en treedt er een compilatietijdfout op.

12.8.5 Haakjes geplaatste expressies

Een parenthesized_expression bestaat uit een expressie tussen haakjes.

parenthesized_expression
    : '(' expression ')'
    ;

Een parenthesized_expression wordt geëvalueerd door de expressie tussen de haakjes te evalueren. Als de expressie tussen de haakjes een naamruimte of type aangeeft, treedt er een compilatietijdfout op. Anders is het resultaat van de parenthesized_expression het resultaat van de evaluatie van de ingesloten expressie.

12.8.6 Tuple-expressies

Een tuple_expression vertegenwoordigt een tuple en bestaat uit twee of meer door komma's gescheiden en optioneel benoemde expressietussen haakjes. Een deconstruction_expression is een verkorte syntaxis voor een tuple die impliciet getypte declaratie-uitdrukkingen bevat.

tuple_expression
    : '(' tuple_element (',' tuple_element)+ ')'
    | deconstruction_expression
    ;
    
tuple_element
    : (identifier ':')? expression
    ;
    
deconstruction_expression
    : 'var' deconstruction_tuple
    ;
    
deconstruction_tuple
    : '(' deconstruction_element (',' deconstruction_element)+ ')'
    ;

deconstruction_element
    : deconstruction_tuple
    | identifier
    ;

Een tuple_expression wordt geclassificeerd als een tuple.

Een deconstruction_expressionvar (e1, ..., en) is een afkorting voor de tuple_expression(var e1, ..., var en) en volgt hetzelfde gedrag. Dit geldt recursief voor geneste deconstruction_tuples in de deconstruction_expression. Elke id die in een deconstruction_expression genest , introduceert dus een declaratie-expressie (§12.19). Als gevolg hiervan kan een deconstruction_expression zich alleen aan de linkerkant van een eenvoudige opdracht voordoen.

Voorbeeld: De volgende code declareert drie variabelen: a, b en c. Elk van hen is een geheel getal en krijgt zijn waarde van de tuple aan de rechterkant van de toewijzing.

var (a, b, c) = (1, 2, 3); // a is 1, b is 2, and c is 3.
var sum = a + b + c; // sum is 6.

Elk van de afzonderlijke elementen van de opdracht kan zelf een deconstructie-uitdrukking zijn. Met de volgende deconstructie-expressie worden bijvoorbeeld zes variabelen toegewezen, a via f.

var (a, b, (c, d, (e, f))) = (1, 2, (3, 4, (5, 6)));

In dit voorbeeld ziet u dat de structuur van geneste tuples aan beide zijden van de toewijzing moet overeenkomen.

Als de variabelen aan de linkerkant impliciet worden getypt, moet de bijbehorende expressie een type hebben:

(int a, string? b) = (42, null); //OK
var (c, d) = (42, null); // Invalid as type of d cannot be inferred
(int e, var f) = (42, null); // Invalid as type of f cannot be inferred

einde voorbeeld

Een tuple-expressie heeft een type als en alleen als elk van de elementexpressies Ei een type Tiheeft. Het type moet een tupletype van dezelfde ariteit zijn als de tuple-expressie, waarbij elk element wordt gegeven door het volgende:

• Als het tuple-element in de overeenkomstige positie een naam heeft Ni, wordt het tupeltypeelement Ti Ni.
• Als Ei in de vorm van Ni of E.Ni of E?.Ni is, dan wordt het tuplet-type-element Ti Ni, tenzij een van de volgende voorwaarden geldt:.
  • Een ander element van de tuple-expressie heeft de naam Niof
  • Een ander tuple-element zonder naam heeft een tuple-elementexpressie van de vorm Ni of E.Ni of E?.Ni, of
  • Ni is van de vorm ItemX, waarbij X een reeks niet-0geïnitieerde decimalen is die de positie van een tuple-element kunnen vertegenwoordigen en X niet de positie van het element vertegenwoordigt.
• Anders moet het tupel-type-element Tizijn.

Een tuple-expressie wordt geëvalueerd door elk van de elementexpressies te evalueren in volgorde van links naar rechts.

Een tuple-waarde kan worden verkregen uit een tuple-expressie door deze te converteren naar een tupletype (§10.2.13), door deze opnieuw te classificeren als een waarde (§12.2.2)) of door deze het doel te maken van een deconstructingtoewijzing (§12.23.2).

voorbeeld van:

(int i, string) t1 = (i: 1, "One");
(long l, string) t2 = (l: 2, null);
var t3 = (i: 3, "Three");          // (int i, string)
var t4 = (i: 4, null);             // Error: no type

In dit voorbeeld zijn alle vier de tuple-expressies geldig. De eerste twee, t1 en t2, gebruiken niet het type tuple-expressie, maar passen in plaats daarvan een impliciete tupleconversie toe. In het geval van t2is de impliciete tuple-conversie afhankelijk van de impliciete conversies van 2 naar long en van null naar string. De derde tuple-expressie heeft een type (int i, string)en kan daarom opnieuw worden geclassificeerd als een waarde van dat type. De declaratie van t4daarentegen is een fout: de tuple-expressie heeft geen type omdat het tweede element geen type heeft.

if ((x, y).Equals((1, 2))) { ... };

In dit voorbeeld zal je zien dat tuples soms kunnen leiden tot meerdere lagen van haakjes, vooral wanneer de tuple-expressie het enige argument is bij een methodeaanroep.

einde voorbeeld

12.8.7 Toegang tot leden

12.8.7.1 Algemeen

Een member_access bestaat uit een primary_expression, een predefined_typeof een qualified_alias_member, gevolgd door een "." token, gevolgd door een identifier, eventueel gevolgd door een type_argument_list.

member_access
    : primary_expression '.' identifier type_argument_list?
    | predefined_type '.' identifier type_argument_list?
    | qualified_alias_member '.' identifier type_argument_list?
    ;

predefined_type
    : 'bool' | 'byte' | 'char' | 'decimal' | 'double' | 'float' | 'int'
    | 'long' | 'object' | 'sbyte' | 'short' | 'string' | 'uint' | 'ulong'
    | 'ushort'
    ;

De qualified_alias_member productie wordt gedefinieerd in §14.8.

Een member_access is of de vorm E.I of van de vorm E.I<A₁, ..., Aₑ>, waarbij E een primary_expression, predefined_type of qualified_alias_member is,I een enkele identifier is, en <A₁, ..., Aₑ> een optionele type_argument_listis. Als er geen type_argument_list is opgegeven, wordt e als nul beschouwd.

Een member_access met een primary_expression van het type dynamic is dynamisch gebonden (§12.3.3). In dit geval wordt de toegang tot leden geclassificeerd als een eigenschapstoegang van het type dynamic. De onderstaande regels om de betekenis van de member_access te bepalen, worden vervolgens toegepast tijdens runtime, met behulp van het runtimetype in plaats van het compileertijdtype van de primary_expression. Als deze runtime-classificatie leidt tot een methodegroep, dan zal de toegang tot het lid bestaan uit de primary_expression binnen een invocation_expression.

De member_access wordt als volgt geëvalueerd en geclassificeerd:

• Als e nul is en E een naamruimte is en E een geneste naamruimte met naam Ibevat, is het resultaat die naamruimte.
• Als E een naamruimte is en E een toegankelijk type met een naam I en K typeparameters bevat, is het resultaat dat het type is samengesteld met de opgegeven typeargumenten.
• Als E is geclassificeerd als een type, als E geen typeparameter is en als een lidzoekactie (§12,5) van I in E met K typeparameters een overeenkomst produceert, wordt E.I als volgt geëvalueerd en geclassificeerd:

  Opmerking: wanneer het resultaat van een dergelijke lidzoekactie een methodegroep is en K nul is, kan de methodegroep methoden met typeparameters bevatten. Hierdoor kunnen dergelijke methoden worden overwogen voor het afleiden van het typeargument. eindnotitie

  • Als I een type identificeert, is het resultaat dat type samengesteld met gegeven typeargumenten.
  • Als I een of meer methoden identificeert, is het resultaat een methodegroep zonder bijbehorende exemplaarexpressie.
  • Als I een statische eigenschap identificeert, is het resultaat een eigenschapstoegang zonder bijbehorende exemplaarexpressie.
  • Als I een statisch veld identificeert:
    • Als het veld alleen-lezen is en de verwijzing plaatsvindt buiten de statische constructor van de klasse of struct waarin het veld wordt gedeclareerd, dan is het resultaat een waarde, namelijk die van het statische veld I in E.
    • Anders is het resultaat een variabele, namelijk het statische veld I in E.
  • Als I een statische gebeurtenis identificeert:
    • Als de verwijzing plaatsvindt in de klasse of instructie waarin de gebeurtenis wordt gedeclareerd en de gebeurtenis is gedeclareerd zonder event_accessor_declarations (§15.8.1), wordt E.I precies verwerkt alsof I een statisch veld zijn.
    • Anders is het resultaat een gebeurtenistoegang zonder bijbehorende exemplaarexpressie.
  • Als I een constante identificeert, is het resultaat een waarde, namelijk de waarde van die constante.
  • Als I een opsommingslid identificeert, is het resultaat een waarde, namelijk de waarde van dat opsommingslid.
  • Anders is E.I een ongeldige lidverwijzing en treedt er een compilatiefout op.
• Als E een eigenschapstoegang, indexeerfunctietoegang, variabele of waarde is, waarvan het type Tis en een lidzoekactie (§12,5) van I in T met K typeargumenten een overeenkomst oplevert, wordt E.I als volgt geëvalueerd en geclassificeerd:
  • Als E een eigenschap of indexeerfunctietoegang is, wordt de waarde van de toegang tot de eigenschap of indexeerfunctie verkregen (§12.2.2) en wordt E opnieuw geclassificeerd als een waarde.
  • Als I een of meer methoden identificeert, is het resultaat een methodegroep met een bijbehorende exemplaarexpressie van E.
  • Als I een exemplaareigenschap identificeert, is het resultaat een eigenschapstoegang met een bijbehorende exemplaarexpressie van E en een gekoppeld type dat het type van de eigenschap is. Als T een klassetype is, wordt het bijbehorende type gekozen uit de eerste declaratie of override van de eigenschap die wordt gevonden door te beginnen met Ten vervolgens door de basisklassen te zoeken.
  • Als T een class_type is en I een exemplaarveld van die class_typeidentificeert:
    • Als de waarde van Enullis, wordt er een System.NullReferenceException gegenereerd.
    • Als het veld anderszins readonly is en de verwijzing buiten de instantieconstructor van de klasse waarin het veld gedeclareerd wordt, dan is het resultaat een waarde, namelijk de waarde van het veld I in het object die door Ewordt gerefereerd.
    • Anders is het resultaat een variabele, namelijk het veld I in het object waarnaar wordt verwezen door E.
  • Als T een struct_type is en I een exemplaarveld van die struct_typeidentificeert:
    • Als E een waarde is, of als het veld alleen-lezen is en de verwijzing plaatsvindt buiten een instantieconstructor van de structuur waarin het veld is gedeclareerd, dan is het resultaat een waarde, namelijk die van het veld I binnen het door Egegeven structuurexemplaar.
    • Anders is het resultaat een variabele, namelijk het veld I in het struct-exemplaar dat is gegeven door E.
  • Als I een instantie-gebeurtenis identificeert:
    • Als de verwijzing plaatsvindt in de klasse of de struct waarin de gebeurtenis wordt gedeclareerd en de gebeurtenis is gedeclareerd zonder event_accessor_declarations (§15.8.1), en de verwijzing niet voorkomt als de linkerkant van a += of -= operator, wordt E.I precies verwerkt alsof I een exemplaarveld is.
    • Anders is het resultaat een gebeurtenistoegang met een bijbehorende instantie-uitdrukking van E.
• Anders wordt geprobeerd om E.I te verwerken als een aanroep van een uitbreidingsmethode (§12.8.10.3). Als dit mislukt, is E.I een ongeldige lidverwijzing en treedt er een bindingstijdfout op.

12.8.7.2 Identieke eenvoudige namen en typenamen

Als bij een lidtoegang van de vorm E.IE een enkele identificator is, en als de betekenis van E als een simple_name (§12.8.4) een constante, veld, eigenschap, lokale variabele of parameter is met hetzelfde type als de betekenis van E als een type_name (§7.8.1), dan zijn beide interpretaties van E toegestaan. Het opzoeken van leden van E.I is nooit ondubbelzinnig, aangezien I in beide gevallen noodzakelijkerwijs tot het type E behoort. Met andere woorden, de regel maakt simpelweg toegang tot de statische leden en geneste typen van E mogelijk waar anders een compilatiefout zou zijn opgetreden.

voorbeeld van:

struct Color
{
    public static readonly Color White = new Color(...);
    public static readonly Color Black = new Color(...);
    public Color Complement() => new Color(...);
}

class A
{
    public «Color» Color;              // Field Color of type Color

    void F()
    {
        Color = «Color».Black;         // Refers to Color.Black static member
        Color = Color.Complement();  // Invokes Complement() on Color field
    }

    static void G()
    {
        «Color» c = «Color».White;       // Refers to Color.White static member
    }
}

Uitsluitend voor verklarende doeleinden, binnen de A-klasse, worden de exemplaren van de Color-identificator die naar het Color-type verwijzen, gemarkeerd met «...», terwijl degenen die naar het Color-veld verwijzen dat niet worden.

einde voorbeeld

12.8.8 Null-voorwaardelijke lidtoegang

Een null_conditional_member_access is een voorwaardelijke versie van member_access (§12.8.7) en is een bindingstijdfout als het resultaattype is void. Zie voor een null-voorwaardelijke expressie waarin het resultaattype kan worden void (§12.8.11).

Een null_conditional_member_access bestaat uit een primary_expression gevolgd door de twee tokens '?' en ''., gevolgd door een id met een optionele type_argument_list, gevolgd door nul of meer dependent_accesses die door een null_forgiving_operator kunnen worden voorafgegaan.

null_conditional_member_access
    : primary_expression '?' '.' identifier type_argument_list?
      (null_forgiving_operator? dependent_access)*
    ;
    
dependent_access
    : '.' identifier type_argument_list?    // member access
    | '[' argument_list ']'                 // element access
    | '(' argument_list? ')'                // invocation
    ;

null_conditional_projection_initializer
    : primary_expression '?' '.' identifier type_argument_list?
    ;

Een null_conditional_member_access expressie E heeft de vorm P?.A. De betekenis van E wordt als volgt bepaald:

• Als het type P een null-waardetype is:

  Laat T het type P.Value.Azijn.

  • Als T een typeparameter is waarvan niet bekend is of het een verwijzingstype of een waarde-type dat niet null is, optreedt er een fout tijdens de compilatietijd.

  • Als T een niet-null-waardetype is, wordt het type ET?en is de betekenis van E hetzelfde als de betekenis van:

    ((object)P == null) ? (T?)null : P.Value.A
    

    Behalve dat P slechts één keer wordt geëvalueerd.

  • Anders is het type ETen is de betekenis van E hetzelfde als de betekenis van:

    ((object)P == null) ? (T)null : P.Value.A
    

    Behalve dat P slechts één keer wordt geëvalueerd.

• Anders:

  Laat T het type expressie P.Azijn.

  • Als T een typeparameter is waarvan niet bekend is of het een verwijzingstype of een waarde-type dat niet null is, optreedt er een fout tijdens de compilatietijd.

  • Als T een niet-null-waardetype is, wordt het type ET?en is de betekenis van E hetzelfde als de betekenis van:

    ((object)P == null) ? (T?)null : P.A
    

    Behalve dat P slechts één keer wordt geëvalueerd.

  • Anders is het type ETen is de betekenis van E hetzelfde als de betekenis van:

    ((object)P == null) ? (T)null : P.A
    

    Behalve dat P slechts één keer wordt geëvalueerd.

Opmerking: In een expressie van het formulier:

P?.A₀?.A₁

Als P naar null evalueert, worden noch A₀ noch A₁ geëvalueerd. Hetzelfde geldt als een expressie een reeks null_conditional_member_access of null_conditional_element_access§12.8.13 bewerkingen is.

eindnotitie

Een null_conditional_projection_initializer is een beperking van null_conditional_member_access en heeft dezelfde semantiek. Dit gebeurt alleen als een projectie-initialisatiefunctie in een anonieme expressie voor het maken van objecten (§12.8.17.3).

12.8.9 Null-forgiving expressies

12.8.9.1 Algemeen

De waarde, het type, de classificatie (§12.2) en de veilige context (§16.4.15) van een null-vergeefse expressie zijn de waarde, het type, de classificatie en de veilige context van de primary_expression.

null_forgiving_expression
    : primary_expression null_forgiving_operator
    ;

null_forgiving_operator
    : '!'
    ;

Opmerking: de logische negatieoperators voor het postfix null-forgiving en voorvoegsel (§12.9.4), terwijl deze worden vertegenwoordigd door hetzelfde lexicale token (!), zijn verschillend. Alleen de laatste kan overbelast zijn (§15.10), de definitie van de operator null-forgiving is opgelost. eindnotitie

Het is een compilatiefout om de null-vergevingsoperator meer dan één keer toe te passen op dezelfde uitdrukking, ongeacht tussenliggende haakjes.

voorbeeld: de volgende zijn allemaal ongeldig:

var p = q!!;            // error: applying null_forgiving_operator more than once
var s = ( ( m(t) ! ) )! // error: null_forgiving_operator applied twice to m(t)

einde voorbeeld

De rest van deze subclause en de volgende subclauses zijn voorwaardelijk normatief.

Een compiler die statische null-statusanalyse uitvoert (§8.9.5) moet voldoen aan de volgende specificatie.

De null-vergevingsgezinde operator is een pseudo-bewerking op compilatietijd die wordt gebruikt om de compiler te voorzien van informatie voor de statische analyse van de null-status. Het heeft twee toepassingen: om de beslissing van een compiler te negeren dat een expressie misschien null is; en om een waarschuwing van een compiler met betrekking tot nullwaarde te onderdrukken.

Het toepassen van de null-forgiving operator op een expressie waarvoor de statische null-analyse van een compiler geen waarschuwingen geeft, is geen fout.

12.8.9.2 Het overschrijven van een 'misschien null'-bepaling

In sommige gevallen kan de statische null-statusanalyse van een compiler bepalen dat een expressie de null-status heeft misschien null- en een diagnostische waarschuwing geeft wanneer andere informatie aangeeft dat de expressie niet null kan zijn. Het toepassen van de null-vergevingsoperator op een dergelijke expressie informeert de statische null-statusanalyse van de compiler dat de null-status zich in bevindt en niet in null-. Hierdoor wordt de diagnostische waarschuwing voorkomen en kan dit invloed hebben op lopende analyses.

Voorbeeld: Houd rekening met het volgende:

#nullable enable
public static void M()
{
    Person? p = Find("John");                  // returns Person?
    if (IsValid(p))
    {
       Console.WriteLine($"Found {p!.Name}");  // p can't be null
    }
}

public static bool IsValid(Person? person) =>
    person != null && person.Name != null;

Als IsValidtrueretourneert, kan p veilig worden gedereferentieerd om toegang te krijgen tot de eigenschap Name en kan de waarschuwing "dereferencing van een mogelijk nullwaarde" worden onderdrukt met behulp van !.

einde voorbeeld

Voorbeeld: De null-forgiving operator moet voorzichtig worden gebruikt; overweeg het volgende:

#nullable enable
int B(int? x)
{
    int y = (int)x!; // quash warning, throw at runtime if x is null
    return y;
}

Hier wordt de null-forgiving-operator toegepast op een waardetype en onderdrukt deze eventuele waarschuwingen voor x. Als x tijdens runtime echter null is, treedt er een uitzondering op omdat null niet naar intkan worden gecast.

einde voorbeeld

12.8.9.3 Overschaduwen van andere null-analysewaarschuwingen

Naast het overschrijven van misschien null- bepaling zoals hierboven, kunnen er andere omstandigheden zijn waarin het wenselijk is om de statische null-statusanalyse van een compiler te overschrijven waarvoor een expressie een of meer waarschuwingen vereist. Het toepassen van de operator null-forgiving op een dergelijke expressie vraagt dat een compiler geen waarschuwingen voor de expressie uitgeeft. Als reactie kan een compiler ervoor kiezen om geen waarschuwingen uit te geven en kan het ook zijn verdere analyse wijzigen.

Voorbeeld: Houd rekening met het volgende:

#nullable enable
public static void Assign(out string? lv, string? rv) { lv = rv; }

public string M(string? t)
{
    string s;
    Assign(out s!, t ?? "«argument was null»");
    return s;
}

De typen van methode Assign's parameters, lv & rv, zijn string?, waarbij lv een uitvoerparameter is en het een eenvoudige toewijzing uitvoert.

Methode M geeft de variabele svan het type stringdoor als uitvoerparameter van Assign. De gebruikte compiler geeft een waarschuwing omdat s geen nullable variabele is. Aangezien het tweede argument van Assignniet null kan zijn, wordt de operator null-forgiving gebruikt om de waarschuwing te vernietigen.

einde voorbeeld

Einde van voorwaardelijk normatieve tekst.

12.8.10 Aanroepexpressies

12.8.10.1 Algemeen

Een invocation_expression wordt gebruikt om een methode aan te roepen.

invocation_expression
    : primary_expression '(' argument_list? ')'
    ;

De primary_expression kan een null_forgiving_expression zijn als en alleen als het een delegate_typeheeft.

Een invocation_expression is dynamisch gebonden (§12.3.3) indien ten minste één van de volgende bewaringen bevat:

• De primary_expression heeft het compilatietijdstype dynamic.
• Ten minste één argument van de optionele argument_list heeft het type compileertijd dynamic.

In dit geval wordt de invocation_expression geclassificeerd als een waarde van het type dynamic. De onderstaande regels om de betekenis van de invocation_expression te bepalen, worden vervolgens tijdens de uitvoering toegepast met behulp van het uitvoeringstijdtype in plaats van het compileertijdtype van de primary_expression en argumenten met het compileertijdtype dynamic. Als het primary_expression geen compileertijdtype heeft dynamic, ondergaat de methodeaanroep een beperkte compileertijdcontrole, zoals beschreven in §12.6.5.

De primary_expression van een invocation_expression moet een methodegroep of een waarde van een delegate_typezijn. Als de primary_expression een methodegroep is, is de invocation_expression een methode-aanroep (§12.8.10.2). Als de primary_expression een waarde van een delegate_typeis, is de invocation_expression een gemachtigde aanroep (§12.8.10.4). Als de primary_expression geen methodegroep of een waarde van een delegate_typeis, treedt er een bindingstijdfout op.

De optionele argument_list (§12.6.2) bevat waarden of variabele verwijzingen voor de parameters van de methode.

Het resultaat van het evalueren van een invocation_expression wordt als volgt geclassificeerd:

• Als de invocation_expression een methode zonder waarde aanroept (§15.6.1) of een machtiging zonder waarde aanroept, is er geen resultaat. Een expressie die als niets wordt geclassificeerd, is alleen toegestaan in de context van een statement_expression (§13.7) of als de hoofdtekst van een lambda_expression (§12.21). Anders treedt er een bindingstijdfout op.
• Anders, als de invocation_expression een methode als 'returns-by-ref' (§15.6.1) of een 'returns-by-ref' gedelegeerde aanroept, is het resultaat een variabele met een type dat overeenkomt met het retourtype van de methode of gedelegeerde. Als het gaat om de aanroep van een instantiemethode en de ontvanger van een klassetype Tis, wordt het bijbehorende type gekozen uit de eerste declaratie of overschrijving van de methode die wordt gevonden door te beginnen met T en de basisklassen door te zoeken.
• Anders roept de invocation_expression een methode aan die een waarde retourneert (§15.6.1) of een delegate die een waarde retourneert, en het resultaat is een waarde met het type dat overeenkomt met het retourtype van de methode of de delegate. Als het gaat om de aanroep van een instantiemethode en de ontvanger van een klassetype Tis, wordt het bijbehorende type gekozen uit de eerste declaratie of overschrijving van de methode die wordt gevonden door te beginnen met T en de basisklassen door te zoeken.

12.8.10.2 Methode-aanroepen

Voor een methode-aanroep moet de primary_expression van de invocation_expression een methodegroep zijn. De methodegroep identificeert de ene methode die moet worden aangeroepen of de set overbelaste methoden waaruit een specifieke methode moet worden gekozen die moet worden aangeroepen. In het laatste geval is de bepaling van de specifieke methode die moet worden aangeroepen, gebaseerd op de context die wordt geboden door de typen argumenten in de argument_list.

De bindingstijdverwerking van een methodeaanroep van het formulier M(A), waarbij M een methodegroep is (mogelijk inclusief een type_argument_list), en A een optionele argument_listis, bestaat uit de volgende stappen:

• De verzameling van kandidaatmethoden voor de methode-aanroep wordt samengesteld. Voor elke methode F gekoppeld aan de methodegroep M:
  • Als F niet-algemeen is, is F een kandidaat wanneer:
    • M heeft geen lijst met typeargumenten en
    • F geldt voor A (§12.6.4.2).
  • Als F algemeen is en M geen lijst met typeargumenten heeft, is F een kandidaat wanneer:
    • Type deductie (§12.6.3) slaagt, waarbij een lijst met typeargumenten voor de aanroep wordt afgeleid en
    • Zodra de uitgestelde typeargumenten worden vervangen door de overeenkomstige parametertypeparameters, voldoen alle samengestelde typen in de parameterlijst van F aan hun beperkingen (§8.4.5) en is de parameterlijst van F van toepassing op A (§12.6.4.2)
  • Als F algemeen is en M een lijst met typeargumenten bevat, is F een kandidaat wanneer:
    • F hetzelfde aantal parameters van het methodetype heeft als die zijn opgegeven in de lijst met typeargumenten en
    • Zodra de typeargumenten worden vervangen door de overeenkomstige parametertypeparameters, voldoen alle samengestelde typen in de parameterlijst van F aan hun beperkingen (§8.4.5), en is de parameterlijst van F van toepassing met betrekking tot A (§12.6.4.2).
• De set kandidaatmethoden wordt beperkt tot alleen methoden van de meest afgeleide typen: voor elke methode C.F in de set, waarbij C het type is waarin de methode F wordt gedeclareerd, worden alle methoden die zijn gedeclareerd in een basistype van C uit de set verwijderd. Als C bovendien een ander klassetype is dan object, worden alle methoden die in een interfacetype zijn gedeclareerd, uit de set verwijderd.

  Opmerking: deze laatste regel heeft alleen een effect wanneer de methodegroep het resultaat was van een opzoekactie van een lid op een typeparameter met een andere effectieve basisklasse dan object en een niet-lege effectieve interfaceset. eindnotitie

• Als de resulterende set kandidaatmethoden leeg is, worden verdere verwerking van de volgende stappen stopgezet en wordt in plaats daarvan geprobeerd de aanroep te verwerken als een extensiemethodeaanroep (§12.8.10.3). Als dit mislukt, bestaan er geen toepasselijke methoden en treedt er een bindingstijdfout op.
• De beste methode van de set kandidaatmethoden wordt geïdentificeerd met behulp van de overbelastingsoplossingsregels van §12.6.4. Als één beste methode niet kan worden geïdentificeerd, is de aanroep van de methode dubbelzinnig en treedt er een bindingstijdfout op. Bij het uitvoeren van overbelastingsresolutie worden de parameters van een algemene methode overwogen na vervanging van de typeargumenten (opgegeven of afgeleid) voor de bijbehorende parameters van het methodetype.

Zodra een methode is geselecteerd en gevalideerd tijdens bindingstijd door de bovenstaande stappen, wordt de werkelijke aanroep van runtime verwerkt volgens de regels van de aanroep van functieleden die worden beschreven in §12.6.6.

Opmerking: Het intuïtieve effect van de hierboven beschreven oplossingsregels is als volgt: Als u de specifieke methode wilt vinden die wordt aangeroepen door een methodeaanroep, begint u met het type dat wordt aangegeven door de methodeaanroep en gaat u verder met de overnameketen totdat ten minste één toepasselijke, toegankelijke, niet-onderdrukkingsmethodedeclaratie wordt gevonden. Voer vervolgens type-inferentie en overbelasting resolutie uit op de reeks toepasselijke, toegankelijke, niet-override methoden die in dat type zijn gedeclareerd en roep de aldus geselecteerde methode aan. Als er geen methode is gevonden, probeert u in plaats daarvan de aanroep te verwerken als een aanroep van de extensiemethode. eindnotitie

12.8.10.3 Uitbreidingsmethode aanroepen

In een methode-aanroep (§12.6.6.2) van een van de formulieren

«expr» . «identifier» ( )  
«expr» . «identifier» ( «args» )  
«expr» . «identifier» < «typeargs» > ( )  
«expr» . «identifier» < «typeargs» > ( «args» )

als bij de normale verwerking van de aanroep geen toepasselijke methoden worden gevonden, wordt geprobeerd de constructie te verwerken als een aanroep van de extensiemethode. Als «expr» of een van de «args» compileertijdtype dynamicheeft, zijn extensiemethoden niet van toepassing.

Het doel is om de beste type_nameCte vinden, zodat de bijbehorende statische methode-aanroep kan plaatsvinden:

C . «identifier» ( «expr» )  
C . «identifier» ( «expr» , «args» )  
C . «identifier» < «typeargs» > ( «expr» )  
C . «identifier» < «typeargs» > ( «expr» , «args» )

Een extensiemethode Cᵢ.Mₑ is in aanmerking komend als:

• Cᵢ is een niet-generieke, niet-geneste klasse
• De naam van Mₑ is identificator
• Mₑ is toegankelijk en van toepassing wanneer deze wordt toegepast op de argumenten als een statische methode, zoals hierboven wordt weergegeven
• Er bestaat een impliciete identiteit-, verwijzings- of boxing-conversie van expr naar het type van de eerste parameter van Mₑ.

De zoekopdracht naar C gaat als volgt:

• Beginnend met de dichtstbijzijnde naamruimtedeclaratie, doorgaand met elke declaratie van de naamruimte en eindigend met de bijbehorende compilatie-eenheid, worden opeenvolgende pogingen gedaan om een kandidaatset met extensiemethoden te vinden:
  • Als de opgegeven naamruimte of compilatie-eenheid rechtstreeks niet-algemene typedeclaraties bevat Cᵢ met in aanmerking komende uitbreidingsmethoden Mₑ, is de set van deze uitbreidingsmethoden de kandidaatset.
  • Als naamruimten die worden geïmporteerd met behulp van naamruimte-instructies in de opgegeven naamruimte of compilatie-eenheid rechtstreeks niet-algemene typedeclaraties Cᵢ met in aanmerking komende extensiemethoden Mₑbevatten, is de set van deze extensiemethoden de kandidaatset.
• Als er in geen enkele omringende naamruimteverklaring of compilatie-eenheid een kandidaatset wordt gevonden, treedt er een compilatietijdfout op.
• Anders wordt overbelastingsafhandeling toegepast op de kandidaatset zoals beschreven in §12.6.4. Als er geen enkele beste methode wordt gevonden, treedt er een compilatietijdfout op.
• C is het type waarin de beste methode wordt gedeclareerd als een extensiemethode.

Met behulp van C als doel wordt de methode-aanroep vervolgens verwerkt als een statische methode-aanroep (§12.6.6).

Opmerking: in tegenstelling tot een aanroep van een instantiemethode wordt er geen uitzondering gegenereerd wanneer expr resulteert in een null-verwijzing. In plaats daarvan wordt deze null waarde doorgegeven aan de extensiemethode, zoals bij een normale statische methode-aanroep. Het is aan de implementatie van de uitbreidingsmethode om te bepalen hoe moet worden gereageerd op een dergelijke oproep. eindnotitie

De voorgaande regels betekenen dat instantiemethoden voorrang hebben op extensiemethoden, dat extensiemethoden die beschikbaar zijn in declaraties van binnennaamruimten voorrang hebben op extensiemethoden die beschikbaar zijn in declaraties van buitennaamruimten, en dat extensiemethoden die rechtstreeks in een naamruimte zijn gedeclareerd voorrang hebben op extensiemethoden die in dezelfde naamruimte zijn geïmporteerd met een using namespace-instructie.

voorbeeld van:

public static class E
{
    public static void F(this object obj, int i) { }
    public static void F(this object obj, string s) { }
}

class A { }

class B
{
    public void F(int i) { }
}

class C
{
    public void F(object obj) { }
}

class X
{
    static void Test(A a, B b, C c)
    {
        a.F(1);            // E.F(object, int)
        a.F("hello");      // E.F(object, string)
        b.F(1);            // B.F(int)
        b.F("hello");      // E.F(object, string)
        c.F(1);            // C.F(object)
        c.F("hello");      // C.F(object)
    }
}

In het voorbeeld heeft de methode van Bvoorrang op de eerste extensiemethode en heeft Cmethode voorrang op beide uitbreidingsmethoden.

public static class C
{
    public static void F(this int i) => Console.WriteLine($"C.F({i})");
    public static void G(this int i) => Console.WriteLine($"C.G({i})");
    public static void H(this int i) => Console.WriteLine($"C.H({i})");
}

namespace N1
{
    public static class D
    {
        public static void F(this int i) => Console.WriteLine($"D.F({i})");
        public static void G(this int i) => Console.WriteLine($"D.G({i})");
    }
}

namespace N2
{
    using N1;

    public static class E
    {
        public static void F(this int i) => Console.WriteLine($"E.F({i})");
    }

    class Test
    {
        static void Main(string[] args)
        {
            1.F();
            2.G();
            3.H();
        }
    }
}

De uitvoer van dit voorbeeld is:

E.F(1)
D.G(2)
C.H(3)

D.G heeft voorrang op C.G, en E.F heeft voorrang op zowel D.F als C.F.

einde voorbeeld

12.8.10.4 Aanroepen delegeren

Voor de aanroep van een delegate moet de primary_expression van de invocation_expression een waarde zijn van een delegate_type. Aangezien de delegate_type bovendien een functielid met dezelfde parameterlijst als de delegate_typeis, is het delegate_type van toepassing (§12.6.4.2) met betrekking tot de argument_list van het invocation_expression.

De runtime-verwerking van een delegate-aanroep van de vorm D(A), waarbij D een primary_expression is van een delegate_type en A een optionele argument_listis, bestaat uit de volgende stappen:

• D wordt geëvalueerd. Als deze evaluatie een uitzondering veroorzaakt, worden er geen verdere stappen uitgevoerd.
• De lijst met argumenten A wordt geëvalueerd. Als deze evaluatie een uitzondering veroorzaakt, worden er geen verdere stappen uitgevoerd.
• De waarde van D is gecontroleerd op geldigheid. Als de waarde van D is null, wordt er een System.NullReferenceException gegenereerd en worden er geen verdere stappen uitgevoerd.
• Anders is D een verwijzing naar een gedelegeerde instantie. Aanroepen van functieleden (§12.6.6) worden uitgevoerd op elk van de aanroepbare entiteiten in de aanroeplijst van de gemachtigde. Voor aanroepbare entiteiten die bestaan uit een instantie en een instantiemethode, is de instantie voor de oproep de instantie in de aanroepbare entiteit.

Zie §21.6 voor meer informatie over meerdere aanroeplijsten zonder parameters.

12.8.11 Null-voorwaardelijke aanroepuitdrukking

Een null_conditional_invocation_expression is syntactisch gezien ofwel een null_conditional_member_access (§12.8.8) of een null_conditional_element_access (§12.8.13), waarbij het laatste dependent_access een aanroepuitdrukking is (§12.8.10).

Een null_conditional_invocation_expression vindt plaats in het kader van een statement_expression (§13.7), anonymous_function_body (§12.21.1) of method_body (§15.6.1).

In tegenstelling tot het syntactisch equivalente null_conditional_member_access of null_conditional_element_access, kan een null_conditional_invocation_expression worden geclassificeerd als niets.

null_conditional_invocation_expression
    : null_conditional_member_access null_forgiving_operator? '(' argument_list? ')'
    | null_conditional_element_access null_forgiving_operator? '(' argument_list? ')'
    ;

De optionele null_forgiving_operator kan worden opgenomen als en slechts als de null_conditional_member_access of null_conditional_element_access een delegate_type heeft.

Een null_conditional_invocation_expression expressie E is van de vorm P?A; waarbij A de rest van de syntactisch equivalente null_conditional_member_access of null_conditional_element_accessis, begint A daarom met . of [. Laten we PA de samenvoeging van P en A.

Wanneer E optreedt als een statement_expression, is de betekenis van E hetzelfde als de betekenis van de -instructie.

if ((object)P != null) PA

behalve dat P slechts één keer wordt geëvalueerd.

Wanneer E voorkomt als een anonymous_function_body of method_body, is de betekenis van E afhankelijk van de classificatie:

• Als E als niets wordt geclassificeerd, is de betekenis ervan hetzelfde als de betekenis van het blok:

  { if ((object)P != null) PA; }
  

  behalve dat P slechts één keer wordt geëvalueerd.

• Anders is de betekenis van E hetzelfde als de betekenis van het blok:

  { return E; }
  

  en op zijn beurt hangt de betekenis van dit blok ervan af of E syntactisch gelijk is aan een null_conditional_member_access (§12.8.8) of null_conditional_element_access (§12.8.13).

12.8.12 Elementtoegang

12.8.12.1 Algemeen

Een element_access bestaat uit een primary_expression, gevolgd door een '[' token, gevolgd door een argument_list, gevolgd door een ']'-token. De argument_list bestaat uit een of meer arguments, gescheiden door komma's.

element_access
    : primary_expression '[' argument_list ']'
    ;

Bij de erkenning van een primary_expression indien zowel de element_access als de pointer_element_access (§24.6.4) alternatieven van toepassing zijn, wordt de laatste gekozen indien de ingesloten primary_expression van het type aanwijzer is (§24.3).

De primary_expression van een element_access mag geen array_creation_expression zijn, tenzij deze een array_initializer bevat, en mag geen stackalloc_expression zijn, tenzij deze een stackalloc_initializer bevat.

Opmerking: Deze beperking is ingesteld om te voorkomen dat er mogelijk verwarrende code ontstaat, zoals:

    var a = new int[3][1];

die anders als volgt zouden worden geïnterpreteerd:

    var a = (new int[3])[1];

Een vergelijkbare beperking geldt voor null_conditional_element_access (§12.8.13). eindnotitie

Een element_access is dynamisch gebonden (§12.3.3) indien ten minste een van de volgende bewaringen geldt:

• De primary_expression heeft het compilatietijdstype dynamic.
• Ten minste één expressie van het argument_list heeft het type compileertijd dynamic.

In dit geval is het type compilatietijd van de element_access afhankelijk van het type compileertijd van de primary_expression: als het een matrixtype heeft, is het type compileertijd het elementtype van dat matrixtype; anders is dynamic het type compileertijd en wordt de element_access geclassificeerd als een waarde van het type dynamic. De onderstaande regels om de betekenis van de element_access te bepalen, worden vervolgens toegepast tijdens runtime, met behulp van het runtimetype in plaats van het type compileertijd van die van de primary_expression en argument_list expressies met het type compileertijd dynamic. Als de primary_expression geen type compilatietijd dynamicheeft, ondergaat de toegang tot het element een beperkte controle van de compilatietijd, zoals beschreven in §12.6.5.

voorbeeld van:

var index = (dynamic)1; // index has compile-time type dynamic
int[] a = {0, 1, 2};
var a_elem = a[index];  // dynamically bound, a_elem has compile-time type int
string s = "012";
var s_elem = s[index];  // dynamcially bound, s_elem has compile-time type dynamic

einde voorbeeld

Als de primary_expression van een element_access is:

• een waarde van een matrixtype, de element_access is een matrixtoegang (§12.8.12.2);
• een waarde van het string type, de element_access is een tekenreekstoegang (§12.8.12.3);
• anders is de primary_expression een variabele of waarde van een klasse, struct of interfacetype met een of meer indexeerleden, in welk geval de element_access een indexeerfunctietoegang is (§12.8.12.4).

12.8.12.2 Matrixtoegang

Voor een matrixtoegang mag de argument_list geen benoemde argumenten of by-reference-argumenten bevatten (§15.6.2.3).

Het aantal expressies in het argument_list moet gelijk zijn aan de rang van de array_type en elke expressie moet:

• van het typeint, uint, of long; of ulong
• alleen voor toegang tot één rangmatrix, van het type Index of ; of Range
• impliciet converteerbaar zijn naar een of meer van de bovenstaande typen.

De runtimeverwerking van een matrixtoegang van het formulier P[A], waarbij P een primary_expression van een array_type is en A een argument_list van indexexpressies is, bestaat uit de volgende stappen:

• P wordt geëvalueerd. Als deze evaluatie een uitzondering veroorzaakt, worden er geen verdere stappen uitgevoerd.
• Voor elke indexexpressie in de argument_list in volgorde, van links naar rechts:
  • De indexexpressie wordt geëvalueerd, laat het type van de resulterende waarde T zijn;
  • Deze waarde wordt vervolgens geconverteerd naar de eerste van de typen: int, uint, long, , ulong, of alleen voor toegang tot één rangmatrix of IndexRange; waarvoor een impliciete conversie (§10.2) van T bestaat.
  • Als de evaluatie van een indexexpressie of de daaropvolgende impliciete conversie een uitzondering veroorzaakt, worden er geen verdere indexexpressies geëvalueerd en worden er geen verdere stappen uitgevoerd.
• De waarde van P is gecontroleerd op geldigheid. Als de waarde van P is null, wordt er een System.NullReferenceException gegenereerd en worden er geen verdere stappen uitgevoerd.
• Als de voorgaande stappen één indexwaarde van het type Range hebben geproduceerd, gaat u als volgt te werk:
  • Laat L de lengte zijn van de matrix waarnaar wordt verwezen door P.
  • A is gecontroleerd of het geldig is met betrekking tot L (§18.3). Als dit niet het probleem is, wordt er een System.ArgumentOutOfRangeException gegenereerd en worden er geen verdere stappen uitgevoerd.
  • De begin offset, S en het aantal artikelen, N, voor A wat betreft L , worden bepaald zoals beschreven voor GetOffsetAndLength (§18.3).
  • Het resultaat van de matrixtoegang is een matrix met een ondiepe kopie van de N-elementen die P beginnen bij index S. Als N nul is, heeft de matrix nulelementen.

Notitie: Zowel S als N kunnen nul zijn ($ 24,3). Het indexeren van een lege matrix is meestal ongeldig, maar indexeren met een leeg bereik vanaf nul is geldig en retourneert een lege matrix. Met de definitie kan S ook L zijn, de afgelopen-eindindex (§18.1), in welk geval N nul is en een lege matrix die wordt geretourneerd. eindnotitie

Notitie: Een bereik van elementen van een matrix kan niet worden toegewezen aan het gebruik van een matrixtoegang. Dit verschilt van de indexeerfunctie (§12.8.12.4) die mogelijk, maar niet, ondersteuning biedt voor een reeks indexen die zijn opgegeven door een Range waarde. eindnotitie

• Anders:
  • Het resultaat van het evalueren van de matrixtoegang is een variabele verwijzing (§9.5) van het elementtype van de matrix.
  • De waarde van elke expressie in de argument_list wordt gecontroleerd aan de hand van de werkelijke limieten van elke dimensie van het matrixexemplaar waarnaar wordt verwezen door P. Als een of meer waarden buiten het bereik vallen, wordt er een System.IndexOutOfRangeException gegenereerd en worden er geen verdere stappen uitgevoerd.
  • De variabele verwijzing van het matrixelement dat door de indexexpressies wordt gegeven, wordt berekend en dit wordt het resultaat van de matrixtoegang.

12.8.12.3 Tekenreekstoegang

Voor een tekenreeks moet de argument_list van het element_access één argument zonder naam bevatten (§15.6.2.2) dat:

• van het type int, Index of ; of Range
• impliciet converteerbaar naar een of meer van de bovenstaande typen.

De runtimeverwerking van een tekenreekstoegang van het formulier P[A], waarbij P een primary_expression van het string type is en A één expressie is, bestaat uit de volgende stappen:

• P wordt geëvalueerd. Als deze evaluatie een uitzondering veroorzaakt, worden er geen verdere stappen uitgevoerd.
• De indexexpressie wordt geëvalueerd, laat het type van de resulterende waarde T zijn;
• Deze waarde wordt vervolgens geconverteerd naar de eerste van de typen: int, Index of Range; waarvoor een impliciete conversie (§10.2) van T bestaat.
• Als de evaluatie van een indexexpressie of de daaropvolgende impliciete conversie een uitzondering veroorzaakt, worden er geen verdere indexexpressies geëvalueerd en worden er geen verdere stappen uitgevoerd.
• De waarde van P is gecontroleerd op geldigheid. Als de waarde van P is null, wordt er een System.NullReferenceException gegenereerd en worden er geen verdere stappen uitgevoerd.
• Als de voorgaande stappen een indexwaarde van het type Range hebben geproduceerd, gaat u als volgt te werk:
  • Het resultaat van het evalueren van de tekenreekstoegang is een waarde van het string type.
  • Laat L de lengte zijn van de tekenreeks waarnaar wordt verwezen.P
  • A is gecontroleerd of het geldig is met betrekking tot L (§18.3), als het niet is, wordt er een System.ArgumentOutOfRangeException gegooid en worden er geen verdere stappen uitgevoerd.
  • De begin offset, S en het aantal artikelen, N, voor A wat betreft L , worden bepaald zoals beschreven voor GetOffsetAndLength (§18.3).
  • Het resultaat van de tekenreekstoegang is een tekenreeks die wordt gevormd door het kopiëren van de N-tekens die P beginnen met S, als N nul is, is de tekenreeks leeg.

Notitie: Zowel S als N mogen nul zijn (§18.3). Het indexeren van een lege tekenreeks is meestal ongeldig, maar indexeren met een leeg bereik vanaf nul is geldig en retourneert een lege tekenreeks. Met de definitie kan S ook L zijn, de laatste-eindindex (§18.1), in welk geval N nul is en een lege tekenreeks wordt geretourneerd. eindnotitie

• Anders:
  • Het resultaat van het evalueren van de tekenreekstoegang is een waarde van het char type.
  • De waarde van de geconverteerde indexexpressie wordt gecontroleerd op basis van de werkelijke grenzen van het tekenreeksexemplaren waarnaar wordt Pverwezen. Als de waarde buiten het bereik valt, wordt er een System.IndexOutOfRangeException gegenereerd en worden er geen verdere stappen uitgevoerd.
  • De waarde van het teken op de verschuiving van de geconverteerde indexexpressie met de tekenreeks P wordt het resultaat van de tekenreekstoegang.

12.8.12.4 Toegang tot indexeerfunctie

Voor toegang tot een indexeerfunctie moet de primary_expression van de element_access een variabele of waarde van een klasse, struct of interfacetype zijn en dit type een of meer indexeerfuncties implementeren die van toepassing zijn op de argument_list van de element_access. De argument_list mag geen argumenten bevatten of out bevattenref.

De bindingstijdverwerking van een indexeerfunctietoegang van het formulier P[A], waarbij P een primary_expression van een klasse, struct of interfacetype Tis en A een argument_list is, bestaat uit de volgende stappen:

• De set van indexeerfuncties die door T wordt geleverd, is samengesteld. De set bestaat uit alle indexeerfuncties die zijn gedeclareerd in T of een basistype van T die geen declaraties overschrijven en die toegankelijk zijn in de huidige context (§7,5).
• De set wordt gereduceerd tot de indexeerfuncties die van toepassing zijn en niet worden verborgen door andere indexeerfuncties. De volgende regels worden toegepast op elke indexeerfunctie S.I in de set, waarbij S het type is waarin de indexeerfunctie I wordt gedeclareerd:
  • Als I niet van toepassing is op A (§12.6.4.2), wordt I uit de set verwijderd.
  • Indien I van toepassing is op A (§12.6.4.2), worden alle indexeerfuncties die zijn gedeclareerd in een basistype van S uit de set verwijderd.
  • Indien I van toepassing is op A (§12.6.4.2) en S een ander klassetype dan objectis, worden alle indexeerfuncties die in een interface zijn gedeclareerd, uit de set verwijderd.
• Als de resulterende set kandidaat-indexeerfuncties leeg is, bestaan er geen toepasselijke indexeerfuncties en treedt er een bindingstijdfout op.
• De beste indexeerfunctie van de set kandidaat-indexeerfuncties wordt geïdentificeerd met behulp van de overbelastingsoplossingsregels van §12.6.4. Als één beste indexeerfunctie niet kan worden geïdentificeerd, is de toegang van de indexeerfunctie niet eenduidig en treedt er een bindingstijdfout op.
• De accessors van de beste indexeerfunctie worden gecontroleerd:
  • Als de toegang tot de indexeerfunctie het doel is van een toewijzing, heeft de indexeerfunctie een set of ref-get accessor, anders treedt er een fout op in de bindingstijd;
  • Anders heeft de indexeerfunctie een get- of ref get-accessor, anders treedt er een bindingstijdfout op.

De runtimeverwerking van de toegang tot de indexeerfunctie bestaat uit de volgende stappen:

• Het doel primary_expressionP wordt geëvalueerd.
• De indexexpressies van de argument_listA worden op volgorde geëvalueerd, van links naar rechts.
• Gebruik de beste indexeerfunctie die tijdens bindingstijd is bepaald:
  • Als de toegang tot de indexeerfunctie het doel is van een toewijzing, wordt de ingestelde toegangs- of verw-toegangsfunctie aangeroepen om een nieuwe waarde toe te wijzen (§12.23.2).
  • In alle andere gevallen wordt de get accessor of ref get accessor aangeroepen om de huidige waarde te verkrijgen (§12.2.2).

12.8.13 Voorwaardelijke toegang tot null-elementen

Een null_conditional_element_access bestaat uit een primary_expression gevolgd door de twee tokens '?' en '[', gevolgd door een argument_list, gevolgd door een ']'-token, gevolgd door nul of meer dependent_accesswaarvan een van deze kan worden voorafgegaan door een null_forgiving_operator.

null_conditional_element_access
    : primary_expression '?' '[' argument_list ']'
      (null_forgiving_operator? dependent_access)*
    ;

De argument_list van een null_conditional_element_access mag geen out of ref argumenten bevatten.

De primary_expression van een null_conditional_element_access mag geen array_creation_expression zijn, tenzij het een array_initializer of een stackalloc_expression bevat, tenzij het een stackalloc_initializer bevat.

Opmerking: Deze beperking bestaat om mogelijk verwarrende code niet toe te laten. Een vergelijkbare beperking is van toepassing op element_access (§12.8.12) waarbij een voorbeeld van wat wordt uitgesloten, kan worden gevonden. eindnotitie

Een null_conditional_element_access is een voorwaardelijke versie van element_access (§12.8.12) en het is een bindingstijdfout als het resultaattype is void. Zie voor een null-voorwaardelijke expressie waarin het resultaattype kan worden void (§12.8.11).

Een null_conditional_element_access expressie E heeft de vorm P?[A]B; waarbij B de dependent_accesszijn, indien aanwezig. De betekenis van E wordt als volgt bepaald:

• Als het type P een null-waardetype is:

  Laat T het type expressie P.Value[A]Bzijn.

  • Als T een typeparameter is waarvan niet bekend is of het een verwijzingstype of een waarde-type dat niet null is, optreedt er een fout tijdens de compilatietijd.

  • Als T een niet-null-waardetype is, wordt het type ET?en is de betekenis van E hetzelfde als de betekenis van:

    ((object)P == null) ? (T?)null : P.Value[A]B
    

    Behalve dat P slechts één keer wordt geëvalueerd.

  • Anders is het type ETen is de betekenis van E hetzelfde als de betekenis van:

    ((object)P == null) ? null : P.Value[A]B
    

    Behalve dat P slechts één keer wordt geëvalueerd.

• Anders:

  Laat T het type expressie P[A]Bzijn.

  • Als T een typeparameter is waarvan niet bekend is of het een verwijzingstype of een waarde-type dat niet null is, optreedt er een fout tijdens de compilatietijd.

  • Als T een niet-null-waardetype is, wordt het type ET?en is de betekenis van E hetzelfde als de betekenis van:

    ((object)P == null) ? (T?)null : P[A]B
    

    Behalve dat P slechts één keer wordt geëvalueerd.

  • Anders is het type ETen is de betekenis van E hetzelfde als de betekenis van:

    ((object)P == null) ? null : P[A]B
    

    Behalve dat P slechts één keer wordt geëvalueerd.

Opmerking: In een expressie van het formulier:

P?[A₀]?[A₁]

Als P evalueert tot null, worden noch A₀, noch A₁ geëvalueerd. Hetzelfde geldt als een expressie een reeks null_conditional_element_access of null_conditional_member_access§12.8.8 bewerkingen is.

eindnotitie

12.8.14 Deze toegang

Een this_access bestaat uit het trefwoord this.

this_access
    : 'this'
    ;

Een this_access is alleen toegestaan in het blok van een instantieconstructor, een instantiemethode, een exemplaartoegangsfunctie (§12.2.1) of een finalizer. Het heeft een van de volgende betekenissen:

• Wanneer this wordt gebruikt in een primary_expression binnen een instantieconstructor van een klasse, wordt deze geclassificeerd als een waarde. Het type van de waarde is het exemplaartype (§15.3.2) van de klasse waarin het gebruik plaatsvindt en de waarde is een verwijzing naar het object dat wordt samengesteld.
• Wanneer this wordt gebruikt in een primary_expression binnen een instantiemethode of instantietoegangsmiddel van een klasse, wordt deze geclassificeerd als een waarde. Het type van de waarde is het exemplaartype (§15.3.2) van de klasse waarin het gebruik plaatsvindt en de waarde is een verwijzing naar het object waarvoor de methode of accessor is aangeroepen.
• Wanneer this wordt gebruikt in een primary_expression binnen een instantieconstructor van een struct, wordt deze geclassificeerd als een variabele. Het type van de variabele is het exemplaartype (§15.3.2) van de struct waarin het gebruik plaatsvindt en de variabele vertegenwoordigt de struct die wordt samengesteld.
  • Als de constructordeclaratie geen constructor-initialisatiefunctie heeft, gedraagt de this variabele zich precies hetzelfde als een uitvoerparameter van het structtype. Dit betekent met name dat de variabele zeker in elk uitvoeringspad van de instantieconstructor moet worden toegewezen.
  • Anders gedraagt de this-variabele zich precies hetzelfde als een ref parameter van het structtype. Dit betekent met name dat de variabele in eerste instantie wordt beschouwd als toegewezen.
• Wanneer this wordt gebruikt in een primary_expression binnen een instantiemethode of instantietoegangsmiddel van een struct, wordt deze geclassificeerd als een variabele. Het type variabele is het exemplaartype (§15.3.2) van de struct waarin het gebruik plaatsvindt.
  • Als de methode of accessor geen iterator is (§15.15) of asynchrone functie (§15.14), vertegenwoordigt de this variabele de struct waarvoor de methode of accessor is aangeroepen.
    • Als de struct een readonly structis, gedraagt de this variabele zich precies hetzelfde als een invoerparameter van het structtype
    • Anders gedraagt de this-variabele zich precies hetzelfde als een ref parameter van het structtype
  • Als de methode of accessor een iterator- of asynchrone functie is, vertegenwoordigt de this variabele een kopie van de struct waarvoor de methode of accessor is aangeroepen en gedraagt zich precies hetzelfde als een waarde parameter van het structtype.

Het gebruik van this in een primary_expression in een andere context dan de hierboven genoemde is een compilatiefout. Het is met name niet mogelijk om te verwijzen naar this in een statische methode, een accessor voor statische eigenschappen of in een variable_initializer van een velddeclaratie.

12.8.15 Basistoegang

Een base_access bestaat uit het trefwoord base gevolgd door een token ".", een identificator en een optionele type_argument_list, of een argument_list tussen vierkante haken.

base_access
    : 'base' '.' identifier type_argument_list?
    | 'base' '[' argument_list ']'
    ;

Een base_access wordt gebruikt voor toegang tot basisklasseleden die zijn verborgen door leden met vergelijkbare namen in de huidige klasse of structuur. Een base_access is alleen toegestaan in de hoofdtekst van een constructor van een instantie, een methode van een instantie, een toegangsfunctie van een instantie (§12.2.1) of een finalizer. Wanneer base.I plaatsvindt in een klasse of struct, geeft I een lid van de basisklasse van die klasse of struct aan. Wanneer base[E] plaatsvindt in een klasse, moet een toepasselijke indexeerfunctie ook aanwezig zijn in de basisklasse.

Tijdens de bindingstijd worden base_access expressies van de vorm base.I en base[E] exact geëvalueerd alsof ze zijn geschreven ((B)this).I en ((B)this)[E], waarbij B de basisklasse is van de klasse of struct waarin de constructie plaatsvindt. Daarom komen base.I en base[E] overeen met this.I en this[E], behalve this wordt weergegeven als een exemplaar van de basisklasse.

Wanneer een base_access verwijst naar een lid van een virtuele functie (een methode, eigenschap of indexeerfunctie), wordt de bepaling van welk functielid tijdens runtime moet worden aangeroepen (§12.6.6) gewijzigd. Het functielid dat wordt aangeroepen, wordt bepaald door de meest afgeleide implementatie (§15.6.4) van het functielid te vinden met betrekking tot B (in plaats van het uitvoeringstype van this, zoals gebruikelijk in een niet-basistoegang). Zo kan binnen een overschrijving van een virtuele functielid een base_access worden gebruikt om de overgenomen implementatie van het functielid aan te roepen. Als het functielid waarnaar wordt verwezen door een base_access abstract is, treedt er een bindingstijdfout op.

Opmerking: in tegenstelling tot thisis base geen expressie op zichzelf. Het is een trefwoord dat alleen wordt gebruikt in de context van een base_access of een constructor_initializer (§15.11.2). eindnotitie

12.8.16 Postfix incrementeer- en decrementeeroperators

post_increment_expression
    : primary_expression '++'
    ;

post_decrement_expression
    : primary_expression '--'
    ;

De operand van een bewerking voor het verhogen of verlagen van een voorvoegsel moet een expressie zijn die is geclassificeerd als een variabele, een eigenschapstoegang of een indexeerfunctietoegang. Het resultaat van de bewerking is een waarde van hetzelfde type als de operand.

Als het primary_expression het type compileertijd heeft dynamic, is de operator dynamisch gebonden (§12.3.3), heeft de post_increment_expression of post_decrement_expression het type compileertijd dynamic en worden de volgende regels toegepast tijdens runtime met behulp van het uitvoeringstype van de primary_expression.

Als de operand van een bewerking voor het verhogen of verlagen van een postfix een eigenschaps- of indexeerfunctietoegang is, moet de eigenschap of indexeerfunctie zowel een get- als een settoegangsfunctie hebben. Als dit niet het geval is, treedt er een bindingstijdfout op.

De oplossing voor overbelasting van unaire operatoren (§12.4.4) wordt toegepast om een specifieke operator-implementatie te selecteren. Vooraf gedefinieerde ++- en -- operators bestaan voor de volgende typen: sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimalen een opsommingstype. De vooraf gedefinieerde ++ operators retourneren de waarde die wordt geproduceerd door 1 toe te voegen aan de operand en de vooraf gedefinieerde -- operators retourneren de waarde die wordt geproduceerd door 1 af te trekken van de operand. Als in een gecontroleerde context het resultaat van deze optel- of aftrekking buiten het bereik van het resultaattype valt en het resultaattype een integraal type of opsommingstype is, wordt er een System.OverflowException gegenereerd.

Er moet een impliciete conversie zijn van het retourtype van de geselecteerde unaire operator naar het type van de primary_expression, anders treedt er een compilatietijdfout op.

De uitvoeringstijdverwerking van een postfix-increment- of -decrementbewerking van de vorm x++ of x-- bestaat uit de volgende stappen:

• Als x is geclassificeerd als een variabele:
  • x wordt geëvalueerd om de variabele te produceren.
  • De waarde van x wordt opgeslagen.
  • De opgeslagen waarde van x wordt geconverteerd naar het operandtype van de geselecteerde operator en de operator wordt aangeroepen met deze waarde als argument.
  • De waarde die door de operator wordt geretourneerd, wordt geconverteerd naar het type x en opgeslagen op de locatie die is opgegeven door de eerdere evaluatie van x.
  • De opgeslagen waarde van x wordt het resultaat van de bewerking.
• Als x is geclassificeerd als een eigenschap of indexertoegang:
  • De exemplaarexpressie (als x niet staticis) en de lijst met argumenten (als x een indexeerfunctietoegang is) die aan x is gekoppeld, worden geëvalueerd en de resultaten worden gebruikt in de daaropvolgende aanroepen van de get- en set-toegangsmethodes.
  • De get accessor van x wordt aangeroepen en de geretourneerde waarde wordt opgeslagen.
  • De opgeslagen waarde van x wordt geconverteerd naar het operandtype van de geselecteerde operator en de operator wordt aangeroepen met deze waarde als argument.
  • De waarde die door de operator wordt geretourneerd, wordt geconverteerd naar het type x en de set accessor van x wordt aangeroepen met deze waarde als waardeargument.
  • De opgeslagen waarde van x wordt het resultaat van de bewerking.

De ++ en -- operators ondersteunen ook voorvoegsel notatie (§12.9.7). Het resultaat van x++ of x-- is de waarde van xvóór de bewerking, terwijl het resultaat van ++x of --x de waarde van xis na de bewerking. In beide gevallen heeft x zelf dezelfde waarde na de bewerking.

Een operator ++- of operator ---implementatie kan worden aangeroepen met behulp van een achtervoegsel- of voorvoegselnotatie. Het is niet mogelijk om afzonderlijke operator-implementaties te hebben voor de twee notaties.

12.8.17 De nieuwe operator

12.8.17.1 Algemeen

De operator new wordt gebruikt om nieuwe exemplaren van typen te maken.

Er zijn drie vormen van nieuwe expressies:

• Expressies voor het maken van objecten worden gebruikt om nieuwe exemplaren van klassetypen en waardetypen te maken.
• Expressies voor het maken van matrices worden gebruikt om nieuwe exemplaren van matrixtypen te maken.
• Expressies voor het maken van delegates worden gebruikt om instanties van delegate-typen te creëren.

De operator new impliceert het maken van een exemplaar van een type, maar impliceert niet noodzakelijkerwijs toewijzing van geheugen. In het bijzonder vereisen exemplaren van waardetypen geen extra geheugen buiten de variabelen waarin ze zich bevinden en vinden er geen toewijzingen plaats wanneer new wordt gebruikt om instanties van waardetypen te maken.

Opmerking: expressies voor het maken van gedelegeerden maken niet altijd nieuwe instanties. Wanneer de expressie op dezelfde manier wordt verwerkt als een methodegroepconversie (§10,8) of een anonieme functieconversie (§10,7) kan dit ertoe leiden dat een bestaand gemachtigde exemplaar opnieuw wordt gebruikt. eindnotitie

12.8.17.2 Expressies voor het maken van objecten

12.8.17.2.1 Algemeen

Een object_creation_expression wordt gebruikt om een nieuw exemplaar van een class_type of een value_typete maken.

object_creation_expression
    : 'new' type '(' argument_list? ')' object_or_collection_initializer?
    | 'new' type object_or_collection_initializer
    ;

object_or_collection_initializer
    : object_initializer
    | collection_initializer
    ;

Het type van een object_creation_expression is een class_type, een value_typeof een type_parameter. Het type kan geen tuple_type of een abstracte of statische class_typezijn.

De optionele argument_list (§12.6.2) is alleen toegestaan als het type een class_type of een struct_typeis.

Een expressie voor het maken van objecten kan de lijst met constructorargumenten weglaten en haakjes plaatsen, mits deze een object-initialisatiefunctie of verzamelingsinitiizer bevat. Het weglaten van de lijst met constructorargumenten en het insluiten van haakjes is gelijk aan het opgeven van een lege argumentenlijst.

Verwerking van een expressie voor het maken van objecten die een object-initialisatie of verzamelings initializer bevat, bestaat uit de eerste verwerking van de instantieconstructor en vervolgens het verwerken van de initialisaties van het lid of element die zijn opgegeven door de object-initialisatie (§12.8.17.17.2.2.2.2.2) of de initialisatiefunctie voor verzamelingen (§12.8.17.2.3).

Als een van de argumenten in de optionele argument_list het type compileertijd heeft dynamic, is de object_creation_expression dynamisch gebonden (§12.3.3) en worden de volgende regels toegepast tijdens runtime met behulp van het runtimetype van deze argumenten van de argument_list met het type compileertijd dynamic. Het maken van het object ondergaat echter een beperkte controle van de compilatietijd, zoals beschreven in §12.6.5.

De bindingstijdverwerking van een object_creation_expression van het formulier new T(A), waarbij T een class_typeof een value_typeis, en A een optionele argument_listis, bestaat uit de volgende stappen:

• Als T een value_type is en A niet aanwezig is:
  • De object_creation_expression is een standaardconstructor-aanroep. Het resultaat van de object_creation_expression is een waarde van het type T, namelijk de standaardwaarde voor T zoals gedefinieerd in §8.3.3.
• Anders, als T een type_parameter is en A niet aanwezig is:
  • Als er geen waardetypebeperking of constructorbeperking (§15.2.5) is opgegeven voor T, treedt er een bindingstijdfout op.
  • Het resultaat van de object_creation_expression is een waarde van het runtimetype waaraan de typeparameter is gebonden, namelijk het resultaat van het aanroepen van de standaardconstructor van dat type. Het runtimetype kan een verwijzingstype of een waardetype zijn.
• Anders, als T een class_type of een struct_typeis:
  • Als T een abstracte of statische class_typeis, treedt er een compilatietijdfout op.
  • De instantieconstructor die moet worden aangeroepen, wordt bepaald met behulp van de regels voor overbelastingsoplossing van §12.6.4. De set kandidaat-exemplaarconstructors bestaat uit alle toegankelijke exemplaarconstructors die zijn gedeclareerd in T, die van toepassing zijn op A (§12.6.4.2). Als de set kandidaat-exemplaarconstructors leeg is of als één beste exemplaarconstructor niet kan worden geïdentificeerd, treedt er een bindingstijdfout op.
  • Het resultaat van de object_creation_expression is een waarde van het type T, namelijk de waarde die wordt geproduceerd door de instantieconstructor aan te roepen die in de bovenstaande stap is bepaald.
  • Anders is de object_creation_expression ongeldig en treedt er een bindingstijdfout op.

Zelfs als de object_creation_expression dynamisch is gebonden, is het type compileertijd nog steeds T.

De runtimeverwerking van een object_creation_expression van de vorm new T(A), waarbij T een class_type of een struct_type is en A een optionele argument_listis, bestaat uit de volgende stappen:

• Als T een class_typeis:
  • Er wordt een nieuw exemplaar van klasse T toegewezen. Als er onvoldoende geheugen beschikbaar is om het nieuwe exemplaar toe te wijzen, wordt er een System.OutOfMemoryException gegenereerd en worden er geen verdere stappen uitgevoerd.
  • Alle velden van het nieuwe exemplaar worden geïnitialiseerd tot de standaardwaarden (§9,3).
  • De instantieconstructor wordt aangeroepen volgens de regels van het aanroepen van functieleden (§12.6.6). Een verwijzing naar het zojuist toegewezen exemplaar wordt automatisch doorgegeven aan de instantieconstructor en het exemplaar kan als zodanig worden geopend vanuit die constructor.
• Als T een struct_typeis:
  • Een exemplaar van het type T wordt gemaakt door een tijdelijke lokale variabele toe te wijzen. Aangezien een instantieconstructor van een struct_type is vereist om zeker een waarde toe te wijzen aan elk veld van het exemplaar dat wordt gemaakt, is er geen initialisatie van de tijdelijke variabele nodig.
  • De instantieconstructor wordt aangeroepen volgens de regels van het aanroepen van functieleden (§12.6.6). Een verwijzing naar het zojuist toegewezen exemplaar wordt automatisch doorgegeven aan de instantieconstructor en het exemplaar kan als zodanig worden geopend vanuit die constructor.

12.8.17.2.2 Object-initialisators

Een object initialisatie geeft waarden op voor nul of meer velden, eigenschappen of geïndexeerde elementen van een object.

object_initializer
    : '{' member_initializer_list? '}'
    | '{' member_initializer_list ',' '}'
    ;

member_initializer_list
    : member_initializer (',' member_initializer)*
    ;

member_initializer
    : initializer_target '=' initializer_value
    ;

initializer_target
    : identifier
    | '[' argument_list ']'
    ;

initializer_value
    : expression
    | object_or_collection_initializer
    ;

Een object-initialisator bestaat uit een reeks lid-initialisatoren, tussen { en } tokens en gescheiden door komma's. Elke member_initializer wijst een doel aan voor de initialisatie. Een identifier duidt op een toegankelijk veld of een eigenschap van het object dat wordt geïnitialiseerd, terwijl een argument_list tussen vierkante haken de argumenten specificeert voor een toegankelijke indexeerfunctie. Het is een fout dat een object-initialisatiefunctie meer dan één lid initialisatiefunctie voor hetzelfde veld of dezelfde eigenschap bevat.

Opmerking: hoewel een object-initialisatiefunctie niet meer dan één keer hetzelfde veld of dezelfde eigenschap mag instellen, zijn er geen dergelijke beperkingen voor indexeerfuncties. Een object-initialisatiefunctie kan meerdere initialisatiedoelen bevatten die verwijzen naar indexeerfuncties en kunnen zelfs meerdere keren dezelfde indexeerfunctieargumenten gebruiken. eindnotitie

Elke initializer_target wordt gevolgd door een gelijkteken en een expressie, een object-initialisatiefunctie of een verzamelings-initialisatiefunctie. Het is niet mogelijk voor expressies in de object-initialisatiefunctie om te verwijzen naar het zojuist gemaakte object dat het initialiseert.

In het argument_list van een initializer_target is er geen impliciete ondersteuning voor argumenten van het type Index (§18.4.2) of Range (§18.4.3).

Een lid-initialisatiefunctie die een expressie opgeeft nadat het gelijkteken is verwerkt, wordt op dezelfde manier verwerkt als een toewijzing (§12.23.2) aan het doel.

Een lid-initialisatie die een object-initialisatie specificeert na het gelijkteken, is een geneste object-initialisatie, d.w.z. een initialisatie van een ingesloten object. In plaats van een nieuwe waarde toe te wijzen aan het veld of de eigenschap, worden de toewijzingen in de geneste object-initialisatiefunctie behandeld als toewijzingen aan leden van het veld of de eigenschap. Geneste object-initialisatiefuncties kunnen niet worden toegepast op eigenschappen met een waardetype of op alleen-lezenvelden met een waardetype.

Een lidinitialisator die na het gelijkteken een verzamelingsinitialisator specificeert, is een initialisatie van een ingesloten verzameling. In plaats van een nieuwe verzameling toe te wijzen aan het doelveld, de eigenschap of de indexeerfunctie, worden de elementen in de initialisatiefunctie toegevoegd aan de verzameling waarnaar wordt verwezen door het doel. De target moet van een verzamelingstype zijn dat voldoet aan de specificaties in §12.8.17.2.3.

Wanneer een initialisatiedoel verwijst naar een indexeerfunctie, worden de argumenten voor de indexeerfunctie altijd één keer geëvalueerd. Dus zelfs als de argumenten nooit worden gebruikt (bijvoorbeeld vanwege een lege geneste initialisatiefunctie), worden ze geëvalueerd op hun bijwerkingen.

Voorbeeld: De volgende klasse vertegenwoordigt een punt met twee coördinaten:

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

Een exemplaar van Point kan als volgt worden gemaakt en geïnitialiseerd:

Point a = new Point { X = 0, Y = 1 };

Dit heeft hetzelfde effect als

Point __a = new Point();
__a.X = 0;
__a.Y = 1;
Point a = __a;

waarbij __a een onzichtbare en ontoegankelijke tijdelijke variabele is.

In de volgende klasse ziet u een rechthoek die is gemaakt op basis van twee punten en het maken en initialiseren van een Rectangle-exemplaar:

public class Rectangle
{
    public Point P1 { get; set; }
    public Point P2 { get; set; }
}

Een exemplaar van Rectangle kan als volgt worden gemaakt en geïnitialiseerd:

Rectangle r = new Rectangle
{
    P1 = new Point { X = 0, Y = 1 },
    P2 = new Point { X = 2, Y = 3 }
};

Dit heeft hetzelfde effect als

Rectangle __r = new Rectangle();
Point __p1 = new Point();
__p1.X = 0;
__p1.Y = 1;
__r.P1 = __p1;
Point __p2 = new Point();
__p2.X = 2;
__p2.Y = 3;
__r.P2 = __p2;
Rectangle r = __r;

waarbij __r, __p1 en __p2 tijdelijke variabelen zijn die anders onzichtbaar en niet toegankelijk zijn.

Als de constructor van Rectanglede twee ingesloten Point exemplaren toewijst, kunnen ze worden gebruikt om de ingesloten Point exemplaren te initialiseren, in plaats van nieuwe toe te wijzen.

public class Rectangle
{
    public Point P1 { get; } = new Point();
    public Point P2 { get; } = new Point();
}

de volgende constructie kan worden gebruikt om de ingesloten Point exemplaren te initialiseren in plaats van nieuwe exemplaren toe te wijzen:

Rectangle r = new Rectangle
{
    P1 = { X = 0, Y = 1 },
    P2 = { X = 2, Y = 3 }
};

Dit heeft hetzelfde effect als

Rectangle __r = new Rectangle();
__r.P1.X = 0;
__r.P1.Y = 1;
__r.P2.X = 2;
__r.P2.Y = 3;
Rectangle r = __r;

einde voorbeeld

12.8.17.2.3 Initializers voor verzamelingen

Met een initialisatiefunctie voor verzamelingen worden de elementen van een verzameling opgegeven.

collection_initializer
    : '{' element_initializer_list '}'
    | '{' element_initializer_list ',' '}'
    ;

element_initializer_list
    : element_initializer (',' element_initializer)*
    ;

element_initializer
    : non_assignment_expression
    | '{' expression_list '}'
    ;

expression_list
    : expression (',' expression)*
    ;

Een verzamelingsinitializer bestaat uit een reeks elementinitialisaties, tussen { en } tokens en gescheiden door komma's. Met elke element-initialisatiefunctie wordt een element opgegeven dat moet worden toegevoegd aan het verzamelingsobject dat wordt geïnitialiseerd en bestaat uit een lijst met expressies tussen { en } tokens en gescheiden door komma's. Een initialisator voor een element met een enkele expressie kan zonder accolades worden geschreven, maar kan dan geen toewijzingsexpressie zijn om verwarring met lidinitialisatoren te voorkomen. De non_assignment_expression productie wordt gedefinieerd in §12.24.

voorbeeld: hieronder ziet u een voorbeeld van een expressie voor het maken van objecten die een initialisatiefunctie voor verzamelingen bevat:

List<int> digits = new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };

einde voorbeeld

Het verzamelingsobject waarop een verzamelingsinitializer wordt toegepast, moet van een type zijn dat System.Collections.IEnumerable implementeert, anders volgt er een compile-time fout. Voor elk opgegeven element in volgorde van links naar rechts wordt normale opzoekactie toegepast om een lid met de naam Addte vinden. Als het resultaat van het opzoeken van leden geen methodegroep is, treedt er een compilatietijdfout op. Anders wordt overbelastingsresolutie toegepast met de expressielijst van de element-initialisatiefunctie als de argumentenlijst en roept de initialisatiefunctie voor de verzameling de resulterende methode aan. Het verzamelingsobject bevat dus een toepasselijke instantie of extensiemethode met de naam Add voor elke element-initialisatiefunctie.

Voorbeeld: Hieronder ziet u een klasse die een contactpersoon vertegenwoordigt met een naam en een lijst met telefoonnummers, en het maken en initialiseren van een List<Contact>:

public class Contact
{
    public string Name { get; set; }
    public List<string> PhoneNumbers { get; } = new List<string>();
}

class A
{
    static void M()
    {
        var contacts = new List<Contact>
        {
            new Contact
            {
                Name = "Chris Smith",
                PhoneNumbers = { "206-555-0101", "425-882-8080" }
            },
            new Contact
            {
                Name = "Bob Harris",
                PhoneNumbers = { "650-555-0199" }
            }
        };
    }
}

dat hetzelfde effect heeft als

var __clist = new List<Contact>();
Contact __c1 = new Contact();
__c1.Name = "Chris Smith";
__c1.PhoneNumbers.Add("206-555-0101");
__c1.PhoneNumbers.Add("425-882-8080");
__clist.Add(__c1);
Contact __c2 = new Contact();
__c2.Name = "Bob Harris";
__c2.PhoneNumbers.Add("650-555-0199");
__clist.Add(__c2);
var contacts = __clist;

waarbij __clist, __c1 en __c2 tijdelijke variabelen zijn die anders onzichtbaar en niet toegankelijk zijn.

einde voorbeeld

12.8.17.3 Anonieme expressies voor het maken van objecten

Een anonymous_object_creation_expression wordt gebruikt om een object van een anoniem type te maken.

anonymous_object_creation_expression
    : 'new' anonymous_object_initializer
    ;

anonymous_object_initializer
    : '{' member_declarator_list? '}'
    | '{' member_declarator_list ',' '}'
    ;

member_declarator_list
    : member_declarator (',' member_declarator)*
    ;

member_declarator
    : simple_name
    | member_access
    | null_conditional_projection_initializer
    | base_access
    | identifier '=' expression
    ;

Een anonieme object-initialisatiefunctie declareert een anoniem type en retourneert een exemplaar van dat type. Een anoniem type is een naamloos klassetype dat rechtstreeks wordt overgenomen van object. De leden van een anoniem type zijn een reeks alleen-lezen eigenschappen die zijn afgeleid van de anonieme object-initialisatiefunctie die wordt gebruikt om een exemplaar van het type te maken. Een anonieme object-initialisatiefunctie van het formulier

new { p₁=e₁,p₂=e₂, ... pv=ev}

declareert een anoniem type van het formulier

class __Anonymous1
{
    private readonly «T1» «f1»;
    private readonly «T2» «f2»;
    ...
    private readonly «Tn» «fn»;

    public __Anonymous1(«T1» «a1», «T2» «a2»,..., «Tn» «an»)
    {
        «f1» = «a1»;
        «f2» = «a2»;
        ...
        «fn» = «an»;
    }

    public «T1» «p1» { get { return «f1»; } }
    public «T2» «p2» { get { return «f2»; } }
    ...
    public «Tn» «pn» { get { return «fn»; } }
    public override bool Equals(object __o) { ... }
    public override int GetHashCode() { ... }
}

waarbij elke «Tx» het type is van de bijbehorende expressie «ex». De expressie die in een member_declarator wordt gebruikt, heeft een type. Het is een compilatiefout dat een uitdrukking in een member_declaratornull of een anonieme functie is.

De namen van een anoniem type en van de parameter aan de Equals methode worden automatisch gegenereerd door de compiler en kunnen niet worden verwezen in programmatekst.

Binnen hetzelfde programma worden twee anonieme object-initialisatiefuncties die een reeks eigenschappen van dezelfde namen en compileertijdtypen in dezelfde volgorde opgeven, exemplaren van hetzelfde anonieme type produceren.

Voorbeeld: In het voorbeeld

var p1 = new { Name = "Lawnmower", Price = 495.00 };
var p2 = new { Name = "Shovel", Price = 26.95 };
p1 = p2;

de toewijzing op de laatste regel is toegestaan omdat p1 en p2 van hetzelfde anonieme type zijn.

einde voorbeeld

De methoden Equals en GetHashcode voor anonieme typen overschrijven de methoden die zijn overgenomen van objecten worden gedefinieerd in termen van de Equals en GetHashcode van de eigenschappen, zodat twee exemplaren van hetzelfde anonieme type gelijk zijn als en alleen als alle eigenschappen gelijk zijn.

Een liddeclaratie kan worden afgekort tot een eenvoudige naam (§12.8.4), een lidtoegang (§12.8.7), een null-conditionele projectie-initialisator (§12.8.8) of een basistoegang (§12.8.15). Dit wordt een projectie-initialisatie genoemd en is een afkorting voor een declaratie van en toewijzing aan een eigenschap met dezelfde naam. Met name lid-declaraties van de vormen

«identifier», «expr» . «identifier» en «expr» ? . «identifier»

zijn exact gelijk aan respectievelijk het volgende:

«identifier» = «identifier», «identifier» = «expr» . «identifier» en «identifier» = «expr» ? . «identifier»

In een projectie-initialisatiefunctie selecteert de id dus zowel de waarde als het veld of de eigenschap waaraan de waarde is toegewezen. Intuïtief projecteert een projectie initializer niet alleen een waarde, maar ook de naam van de waarde.

12.8.17.4 Expressies voor het maken van matrices

Een array_creation_expression wordt gebruikt om een nieuw exemplaar van een array_typete maken.

array_creation_expression
    : 'new' non_array_type '[' expression_list ']' rank_specifier*
      array_initializer?
    | 'new' array_type array_initializer
    | 'new' rank_specifier array_initializer
    ;

Met een expressie voor het aanmaken van een array in de eerste vorm wordt een arrayinstantie van het type toegewezen die het resultaat is van het verwijderen van elk van de afzonderlijke expressies uit de expressielijst.

voorbeeld: de expressie voor het maken van een array new int[10,20] produceert een arrayexemplaar van het type int[,], en de expressie voor het maken van een nieuwe array int[10][,] produceert een arrayexemplaar van het type int[][,]. einde voorbeeld

Elke expressie in de expressielijst moet van het type int, uint, longof ulongzijn of impliciet kunnen worden omgezet in een of meer van deze typen. De waarde van elke uitdrukking bepaalt de lengte van de bijbehorende dimensie in de nieuw toegewezen array-instantie. Omdat de lengte van een matrixdimensie niet-negatief is, is het een compilatiefout om een constante expressie met een negatieve waarde in de expressielijst te hebben.

Behalve in een onveilige context (§24.2) is de indeling van matrices niet opgegeven.

Als een expressie voor het maken van een matrix van het eerste formulier een initialisatiefunctie voor een matrix bevat, moet elke expressie in de expressielijst een constante zijn en moeten de rang- en dimensielengten die door de expressielijst zijn opgegeven, overeenkomen met die van de initialisatiefunctie van de matrix.

In een expressie voor het maken van een matrix van het tweede of derde formulier moet de rangorde van het opgegeven matrixtype of rangaanduiding overeenkomen met die van de initialisatiefunctie van de matrix. De afzonderlijke dimensielengten worden afgeleid van het aantal elementen in elk van de bijbehorende nestniveaus van de matrix-initialisatiefunctie. De initialisatie-expressie in de volgende declaratie

var a = new int[,] {{0, 1}, {2, 3}, {4, 5}};

komt precies overeen met

var a = new int[3, 2] {{0, 1}, {2, 3}, {4, 5}};

Een expressie voor het maken van een matrix van het derde formulier wordt een impliciet getypte expressie voor het maken van matricesgenoemd. Het is vergelijkbaar met het tweede formulier, behalve dat het elementtype van de matrix niet expliciet wordt opgegeven, maar wordt bepaald als het beste gemeenschappelijke type (§12.6.3.16) van de set expressies in de matrixinitiator. Voor een multidimensionale matrix, d.w.z. een matrix waarin de rank_specifier ten minste één komma bevat, bestaat deze set uit alle expressiesdie zijn gevonden in geneste array_initializers.

Matrix initializers worden verder beschreven in §17.7.

Het resultaat van het evalueren van een expressie voor het aanmaken van een array wordt beschouwd als een waarde, namelijk een verwijzing naar het zojuist toegewezen array-exemplaar. De looptijdverwerking van een expressie voor het maken van een matrix bestaat uit de volgende stappen:

• De dimensielengte-expressies van de expression_list worden op volgorde geëvalueerd, van links naar rechts. Na de evaluatie van elke expressie wordt een impliciete conversie (§10,2) uitgevoerd op een van de volgende typen: int, uint, long, ulong. Het eerste type in deze lijst waarvoor een impliciete conversie bestaat, wordt gekozen. Als de evaluatie van een expressie of de daaropvolgende impliciete conversie een uitzondering veroorzaakt, worden er geen verdere expressies geëvalueerd en worden er geen verdere stappen uitgevoerd.
• De berekende waarden voor de dimensielengten worden als volgt gevalideerd: Als een of meer van de waarden kleiner zijn dan nul, wordt er een System.OverflowException gegenereerd en worden er geen verdere stappen uitgevoerd.
• Een array-exemplaar met de opgegeven dimensielengten wordt toegewezen. Als er onvoldoende geheugen beschikbaar is om het nieuwe exemplaar toe te wijzen, wordt er een System.OutOfMemoryException gegenereerd en worden er geen verdere stappen uitgevoerd.
• Alle elementen van de nieuwe arrayinstanties worden geïnitialiseerd met hun standaardwaarden (§9.3).
• Als de expressie voor het maken van de matrix een initialisatiefunctie voor matrices bevat, wordt elke expressie in de matrix-initialisatie geëvalueerd en toegewezen aan het bijbehorende matrixelement. De evaluaties en toewijzingen worden uitgevoerd in de volgorde waarin de expressies worden geschreven in de initialisatiefunctie van de matrix, met andere woorden: elementen worden geïnitialiseerd in toenemende indexvolgorde, waarbij de meest rechtse dimensie eerst toeneemt. Als de evaluatie van een bepaalde expressie of de volgende toewijzing aan het bijbehorende matrixelement een uitzondering veroorzaakt, worden er geen verdere elementen geïnitialiseerd (en de resterende elementen hebben dus hun standaardwaarden).

Met een expressie voor het maken van een matrix kan een matrix worden geïnstantieerd met elementen van een matrixtype, maar de elementen van een dergelijke matrix moeten handmatig worden geïnitialiseerd.

Voorbeeld: De verklaring

int[][] a = new int[100][];

maakt een eendimensionale matrix met 100 elementen van het type int[]. De initiële waarde van elk element is null. Het is niet mogelijk dat dezelfde uitdrukking voor het maken van een matrix ook de submatrices instantieert, en de instructie

int[][] a = new int[100][5]; // Error

resulteert in een compilatietijdfout. Instantiëring van de submatrices kan in plaats daarvan handmatig worden uitgevoerd, zoals in

int[][] a = new int[100][];
for (int i = 0; i < 100; i++)
{
    a[i] = new int[5];
}

einde voorbeeld

Opmerking: Wanneer een array van arrays een "rechthoekige" vorm heeft, dat wil zeggen wanneer de sub-arrays allemaal dezelfde lengte hebben, is het efficiënter om een multidimensionale array te gebruiken. In het bovenstaande voorbeeld maakt instantiëring van de matrix van matrices 101 objecten: één buitenste matrix en 100 submatrices. Daarentegen,

int[,] a = new int[100, 5];

maakt slechts één object, een tweedimensionale matrix en bereikt de toewijzing in één instructie.

eindnotitie

voorbeeld van: Hieronder ziet u voorbeelden van impliciet getypte expressies voor het maken van matrices:

var a = new[] { 1, 10, 100, 1000 };                     // int[]
var b = new[] { 1, 1.5, 2, 2.5 };                       // double[]
var c = new[,] { { "hello", null }, { "world", "!" } }; // string[,]
var d = new[] { 1, "one", 2, "two" };                   // Error

De laatste expressie veroorzaakt een compilatiefout omdat noch int noch string impliciet converteerbaar is naar de andere, en er is dus geen best gemeenschappelijk type. In dit geval moet een expliciet getypte expressie voor het maken van een array worden gebruikt, bijvoorbeeld door het type object[]op te geven. U kunt ook een van de elementen casten naar een gemeenschappelijk basistype, dat vervolgens het uitgestelde elementtype wordt.

einde voorbeeld

Impliciet getypte expressies voor het maken van matrices kunnen worden gecombineerd met anonieme object initialisatiefuncties (§12.8.17.3) om anoniem getypte gegevensstructuren te maken.

voorbeeld van:

var contacts = new[]
{
    new
    {
        Name = "Chris Smith",
        PhoneNumbers = new[] { "206-555-0101", "425-882-8080" }
    },
    new 
    {
        Name = "Bob Harris",
       PhoneNumbers = new[] { "650-555-0199" }
    }
};

einde voorbeeld

12.8.17.5 Expressies voor het maken van gedelegeerden

Een delegate_creation_expression wordt gebruikt om een exemplaar van een delegate_typete verkrijgen.

delegate_creation_expression
    : 'new' delegate_type '(' expression ')'
    ;

Het argument van een expressie voor het creëren van gedelegeerden moet een methodegroep, een anonieme functie, of een waarde van het compileertijdtype dynamic of een delegate_typezijn. Als het argument een methodegroep is, identificeert het de methode en, voor een instantiemethode, het object waarvoor een gemachtigde moet worden gemaakt. Als het argument een anonieme functie is, definieert het rechtstreeks de parameters en de hoofdtekst van de methode van het gemachtigde doel. Als het argument een waarde is, wordt een delegate-instantie geïdentificeerd waarvan een kopie moet worden gemaakt.

Als de expressie het compilatietijdtype dynamicheeft, is de delegate_creation_expression dynamisch gebonden (§12.8.17.5) en worden de onderstaande regels tijdens runtime toegepast met behulp van het runtimetype van de -expressie. Anders worden de regels tijdens het compileren toegepast.

De bindingstijdverwerking van een delegate_creation_expression van de vorm nieuw D(E), waarbij D een delegate_type is en E een expressieis, bestaat uit de volgende stappen:

• Als E een methodegroep is, wordt de expressie voor het maken van gemachtigden op dezelfde manier verwerkt als een methodegroepconversie (§10,8) van E tot D.

• Als E een anonieme functie is, wordt de expressie voor het maken van gemachtigden op dezelfde manier verwerkt als een anonieme functieconversie (§10,7) van E tot D.

• Indien E een waarde is, E moet deze compatibel zijn (§21.2) met D, en het resultaat is een verwijzing naar een zojuist gemaakte gemachtigde met een aanroeplijst met één vermelding die wordt aangeroepen E.

De runtimeverwerking van een delegate_creation_expression van de vorm new D(E), waarbij D een delegate_type is en E een expressieis, bestaat uit de volgende stappen:

• Als E een methodegroep is, wordt de expressie voor het maken van gemachtigden geëvalueerd als een methodegroepconversie (§10,8) van E naar D.
• Als E een anonieme functie is, wordt de creatie van de delegeer geëvalueerd als een omzetting van anonieme functie van E naar D (§10.7).
• Als E een waarde van een delegate_typeis:
  • E wordt geëvalueerd. Als deze evaluatie een uitzondering veroorzaakt, worden er geen verdere stappen uitgevoerd.
  • Als de waarde van E is null, wordt er een System.NullReferenceException gegenereerd en worden er geen verdere stappen uitgevoerd.
  • Er wordt een nieuw exemplaar van het delegate-type D toegewezen. Als er onvoldoende geheugen beschikbaar is om het nieuwe exemplaar toe te wijzen, wordt er een System.OutOfMemoryException gegenereerd en worden er geen verdere stappen uitgevoerd.
  • Het nieuwe gedelegeerde object wordt geïnitialiseerd met een aanroepingslijst met één item die E aanroept.

De aanroeplijst van een gemachtigde wordt bepaald wanneer de gemachtigde wordt geïnstantieerd en blijft vervolgens constant gedurende de gehele levensduur van de gemachtigde. Met andere woorden, het is niet mogelijk om de aanroepbare doelobjecten van een delegate te wijzigen zodra deze gemaakt is.

Opmerking: Onthoud dat wanneer twee gedelegeerden worden gecombineerd of een van de andere wordt verwijderd, er een nieuwe gedelegeerde ontstaat; de inhoud van geen bestaande gedelegeerde verandert. eindnotitie

Het is niet mogelijk om een gemachtigde te maken die verwijst naar een eigenschap, indexeerfunctie, door de gebruiker gedefinieerde operator, instantieconstructor, finalizer of statische constructor.

Voorbeeld: Zoals hierboven beschreven, wordt bij het maken van een delegate van een methodegroep de parameterlijst en het retourtype van de delegate bepaald welke van de overbelaste methoden worden geselecteerd. In het voorbeeld

delegate double DoubleFunc(double x);

class A
{
    DoubleFunc f = new DoubleFunc(Square);

    static float Square(float x) => x * x;
    static double Square(double x) => x * x;
}

het A.f veld wordt geïnitialiseerd met een gemachtigde die verwijst naar de tweede Square methode, omdat die methode exact overeenkomt met de parameterlijst en het retourtype van DoubleFunc. Als de tweede Square methode niet aanwezig was, zou er een compilatietijdfout zijn opgetreden.

einde voorbeeld

12.8.18 De typeof-operator

De operator typeof wordt gebruikt om het System.Type-object voor een type te verkrijgen.

typeof_expression
    : 'typeof' '(' type ')'
    | 'typeof' '(' unbound_type_name ')'
    | 'typeof' '(' 'void' ')'
    ;

unbound_type_name
    : identifier generic_dimension_specifier?
      ('.' identifier generic_dimension_specifier?)*
    | unbound_qualified_alias_member
      ('.' identifier generic_dimension_specifier?)*
    ;

unbound_qualified_alias_member
    : identifier '::' identifier generic_dimension_specifier?
    ;

generic_dimension_specifier
    : '<' comma* '>'
    ;

comma
    : ','
    ;

nl-NL: De eerste vorm van typeof_expression bestaat uit een typeof trefwoord gevolgd door een type tussen haakjes. Het resultaat van een expressie van dit formulier is het System.Type object voor het aangegeven type. Er is slechts één System.Type object voor een bepaald type. Dit betekent dat voor een type T, typeof(T) == typeof(T) altijd waar is. Het type mag niet dynamiczijn.

De tweede vorm van typeof_expression bestaat uit een typeof trefwoord gevolgd door een unbound_type_nametussen haakjes.

Opmerking: de grammatica van unbound_type_name en unbound_qualified_alias_member volgen die van type_name (§7.8) en qualified_alias_member (§14.8.1), behalve dat generic_dimension_specifiers worden vervangen door type_argument_lists. eindnotitie

Bij de erkenning van de operand van een typeof_expression indien zowel unbound_type_name als type_name van toepassing zijn, namelijk wanneer deze geen generic_dimension_specifier noch een type_argument_list bevat, wordt type_name gekozen.

Opmerking: ANTLR maakt de opgegeven keuze automatisch vanwege de volgorde van de alternatieven van typeof_expression. eindnotitie

De betekenis van een unbound_type_name wordt bepaald alsof:

• De reeks tokens wordt geconverteerd naar een type_name door elke generic_dimension_specifier te vervangen door een type_argument_list met hetzelfde aantal komma's en het trefwoord object als elke type_argument.
• Het resulterende type_name wordt omgezet in een samengesteld type (§7.8).
• De unbound_type_name is vervolgens het niet-afhankelijke algemene type dat is gekoppeld aan het opgeloste samengestelde type (§8.4).

Opmerking: er is geen verplichting voor een implementatie om de volgorde van tokens te transformeren of om het intermediaire samengestelde type te produceren, alleen dat het ongebonden generieke type dat wordt bepaald, 'alsof' dit proces is gevolgd. eindnotitie

Het is een fout als de typenaam een nullable referentietype is.

Het resultaat van de typeof_expression is het System.Type object voor het resulterende ongebonden generieke type.

De derde vorm van typeof_expression bestaat uit een typeof trefwoord, gevolgd door een void trefwoord tussen haakjes. Het resultaat van een expressie van dit formulier is het System.Type object dat de afwezigheid van een type aangeeft. Het typeobject dat wordt geretourneerd door typeof(void) verschilt van het typeobject dat wordt geretourneerd voor elk type.

Opmerking: dit speciale System.Type-object is handig in klassebibliotheken die reflectie op methoden in de taal mogelijk maken, waarbij deze methoden een manier willen hebben om het retourtype van een methode weer te geven, inclusief void methoden, met een exemplaar van System.Type. eindnotitie

De operator typeof kan worden gebruikt voor een typeparameter. Het is een compilatietijdfout als de typenaam een nullable-referentietype is. Het resultaat is het System.Type-object voor het runtimetype dat is gebonden aan de typeparameter. Als het runtimetype een opzichzelfstaande verwijzingstype is, is het resultaat het overeenkomstige niet-opteerbare referentietype. De operator typeof kan ook worden gebruikt voor een samengesteld type of een niet-afhankelijk algemeen type (§8.4.4). Het System.Type-object voor een niet-afhankelijk algemeen type is niet hetzelfde als het System.Type object van het exemplaartype (§15.3.2). Het exemplaartype is altijd een gesloten geconstrueerd type tijdens runtime, zodat het System.Type object afhankelijk is van de argumenten van het runtimetype die in gebruik zijn. Het niet-afhankelijke algemene type heeft daarentegen geen typeargumenten en levert hetzelfde System.Type object op, ongeacht de argumenten van het runtimetype.

voorbeeld: het voorbeeld

class X<T>
{
    public static void PrintTypes()
    {
        Type[] t =
        {
            typeof(int),
            typeof(System.Int32),
            typeof(string),
            typeof(double[]),
            typeof(void),
            typeof(T),
            typeof(X<T>),
            typeof(X<X<T>>),
            typeof(X<>)
        };
        for (int i = 0; i < t.Length; i++)
        {
            Console.WriteLine(t[i]);
        }
    }
}

class Test
{
    static void Main()
    {
        X<int>.PrintTypes();
    }
}

produceert de volgende uitvoer:

System.Int32
System.Int32
System.String
System.Double[]
System.Void
System.Int32
X`1[System.Int32]
X`1[X`1[System.Int32]]
X`1[T]

Houd er rekening mee dat int en System.Int32 hetzelfde type zijn. Het resultaat van typeof(X<>) is niet afhankelijk van het typeargument, maar het resultaat van typeof(X<T>) wel.

einde voorbeeld

12.8.19 De grootte van de operator

De operator sizeof retourneert het aantal 8-bits bytes dat wordt bezet door een variabele van een bepaald type. Het type dat is opgegeven als operand voor sizeof moet een unmanaged_type zijn (§8.8).

sizeof_expression
    : 'sizeof' '(' unmanaged_type ')'
    ;

Voor bepaalde vooraf gedefinieerde typen levert de operator sizeof een constante int waarde op, zoals wordt weergegeven in de onderstaande tabel:

Voor een enumtype Tis het resultaat van de expressie sizeof(T) een constante waarde is die gelijk is aan de grootte van het onderliggende type, zoals hierboven is aangegeven. Voor alle andere operandtypen wordt de sizeof operator opgegeven in §24.6.9.

12.8.20 De gecontroleerde en ongecontroleerde operators

De operators checked en unchecked worden gebruikt om de context voor overloopcontrole te beheren voor rekenkundige bewerkingen en conversies van integraal type.

checked_expression
    : 'checked' '(' expression ')'
    ;

unchecked_expression
    : 'unchecked' '(' expression ')'
    ;

De operator checked evalueert de ingesloten expressie in een gecontroleerde context en de operator unchecked evalueert de ingesloten expressie in een niet-gecontroleerde context. Een checked_expression of unchecked_expression komt precies overeen met een parenthesized_expression (§12.8.5), behalve dat de ingesloten expressie wordt geëvalueerd binnen de gespecificeerde context van overloopcontrole.

De context voor overloopcontrole kan ook worden beheerd via de checked- en unchecked-instructies (§13.12).

De volgende bewerkingen worden beïnvloed door de context van de overloopcontrole die is ingesteld door de gecontroleerde en niet-gecontroleerde operators en instructies:

• De vooraf gedefinieerde ++ operatoren -- (§12.8.16 en §12.9.7), wanneer de operand van een integraal of opsommingstype is.
• De vooraf gedefinieerde - unaire operator (§12.9.3), wanneer de operand van een integraal type is.
• De vooraf gedefinieerde+, -en */ binaire operatoren (§12.12), wanneer beide operanden van integrale of opsommingstypen zijn.
• Expliciete numerieke conversies (§10.3.2) van het ene integraal- of enumtype naar een ander integraal of opsommingstype, of van float of double naar een integraal of opsommingstype.

Wanneer een van de bovenstaande bewerkingen een resultaat produceert dat te groot is om weer te geven in het doeltype, bepaalt de context waarin de bewerking wordt uitgevoerd het resulterende gedrag:

• Als de bewerking in een checked context een constante expressie (§12.25) is, treedt er een compilatietijdfout op. Anders, als de bewerking tijdens runtime wordt uitgevoerd, wordt er een System.OverflowException opgeworpen.
• In een unchecked context wordt het resultaat afgekapt door alle bits in hoge volgorde te verwijderen die niet in het doeltype passen.

Voor niet-constante expressies (§12.25) (expressies die tijdens runtime worden geëvalueerd) die niet zijn ingesloten door een checked of unchecked meer operators of instructies, wordt de standaardoverloopcontrolecontext uitgeschakeld, tenzij externe factoren (zoals compilerswitches en configuratie van de uitvoeringsomgeving) aanroepen voor gecontroleerde evaluatie.

Voor constante expressies (§12.25) (expressies die volledig kunnen worden geëvalueerd tijdens het compileren), wordt de standaardoverloopcontrolecontext altijd gecontroleerd. Tenzij een constante expressie expliciet in een unchecked context wordt geplaatst, veroorzaakt overloop die optreedt tijdens de compilatietijd-evaluatie van de expressie altijd compilatietijdfouten.

De hoofdtekst van een anonieme functie wordt niet beïnvloed door checked of unchecked contexten waarin de anonieme functie plaatsvindt.

Voorbeeld: In de volgende code

class Test
{
    static readonly int x = 1000000;
    static readonly int y = 1000000;

    static int F() => checked(x * y);    // Throws OverflowException
    static int G() => unchecked(x * y);  // Returns -727379968
    static int H() => x * y;             // Depends on default
}

er worden geen compilatiefouten gerapporteerd omdat geen van de expressies tijdens het compileren kan worden geëvalueerd. Tijdens runtime genereert de methode F een System.OverflowExceptionen retourneert de methode G –727379968 (de lagere 32 bits van het buitenbereikresultaat). Het gedrag van de methode H is afhankelijk van de standaardcontext voor overloopcontrole voor de compilatie, maar dit is hetzelfde als F of hetzelfde als G.

einde voorbeeld

Voorbeeld: In de volgende code

class Test
{
    const int x = 1000000;
    const int y = 1000000;

    static int F() => checked(x * y);    // Compile-time error, overflow
    static int G() => unchecked(x * y);  // Returns -727379968
    static int H() => x * y;             // Compile-time error, overflow
}

de overlopen die optreden bij het evalueren van de constante uitdrukkingen in F en H leiden tot compilatietijdfouten omdat de uitdrukkingen worden geëvalueerd in een checked-context. Er treedt ook een overloop op bij het evalueren van de constante expressie in G, maar omdat de evaluatie plaatsvindt in een unchecked context, wordt de overloop niet gerapporteerd.

einde voorbeeld

De operators checked en unchecked beïnvloeden alleen de context van de overloopcontrole voor die bewerkingen die tekstueel zijn opgenomen binnen de tokens '(' en ')'. De operators hebben geen effect op functieleden die worden aangeroepen als gevolg van het evalueren van de ingesloten expressie.

Voorbeeld: In de volgende code

class Test
{
    static int Multiply(int x, int y) => x * y;

    static int F() => checked(Multiply(1000000, 1000000));
}

het gebruik van checked in F heeft geen invloed op de evaluatie van x * y in Multiply, dus x * y wordt geëvalueerd in de standaardoverloopcontrolecontext.

einde voorbeeld

De operator unchecked is handig bij het schrijven van constanten van de ondertekende integrale typen in hexadecimale notatie.

voorbeeld van:

class Test
{
    public const int AllBits = unchecked((int)0xFFFFFFFF);
    public const int HighBit = unchecked((int)0x80000000);
}

Beide hexadecimale constanten hierboven zijn van het type uint. Omdat de constanten buiten het int-bereik vallen, zouden de casts naar unchecked compileertijdfouten produceren zonder de int-operator.

einde voorbeeld

Opmerking: de operators en instructies van de checked en unchecked stellen programmeurs in staat om bepaalde aspecten van sommige numerieke berekeningen te beheren. Het gedrag van sommige numerieke operators is echter afhankelijk van de gegevenstypen van hun operanden. Als u bijvoorbeeld twee decimalen vermenigvuldigt, resulteert dit altijd in een uitzondering op overloop, zelfs binnen een expliciet niet-gecontroleerd constructie. Op dezelfde manier resulteert het vermenigvuldigen van twee floats nooit in een uitzondering op overloop, zelfs binnen een expliciet gecontroleerde constructie. Bovendien worden andere operators nooit beïnvloed door de controlemodus, of dit nu standaard of expliciet is. eindnotitie

12.8.21 Standaardwaardeexpressies

Een standaardwaardeexpressie wordt gebruikt om de standaardwaarde (§9.3) van een type te verkrijgen.

default_value_expression
    : explicitly_typed_default
    | default_literal
    ;

explicitly_typed_default
    : 'default' '(' type ')'
    ;

default_literal
    : 'default'
    ;

Een default_literal vertegenwoordigt een standaardwaarde (§9,3). Het heeft geen type, maar kan worden geconverteerd naar elk type via een standaard letterlijke conversie (§10.2.16).

Het resultaat van een default_value_expression is de standaardwaarde (§9.3) van het expliciete type in een explicitly_typed_default of het doeltype van de conversie voor een default_value_expression.

Een default_value_expression is een constante expressie (§12.25) als het type een van de volgende is:

• een referentietype
• een typeparameter die bekend staat als referentietype (§8.2);
• een van de volgende waardetypen: sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, bool,; of
• elke opsommingstype.

12.8.22 Stacktoewijzing

Met een stackallocatie-expressie wordt een blok geheugen toegewezen vanuit de uitvoeringsstack. De uitvoeringsstack is een geheugengebied waarin lokale variabelen worden opgeslagen. De uitvoeringsstack is geen onderdeel van de beheerde heap. Het geheugen dat wordt gebruikt voor lokale variabele opslag, wordt automatisch hersteld wanneer de huidige functie wordt geretourneerd.

De veilige contextregels voor een stacktoewijzingsexpressie worden beschreven in §16.4.15.7.

stackalloc_expression
    : 'stackalloc' unmanaged_type '[' expression ']'
    | 'stackalloc' unmanaged_type? '[' constant_expression? ']' stackalloc_initializer
    ;

stackalloc_initializer
     : '{' stackalloc_initializer_element_list '}'
     ;

stackalloc_initializer_element_list
     : stackalloc_element_initializer (',' stackalloc_element_initializer)* ','?
     ;
    
stackalloc_element_initializer
    : expression
    ;

De unmanaged_type (§8.8) geeft het type aan van de items die worden opgeslagen op de zojuist toegewezen locatie en de expressie het aantal van deze items aangeeft. Samen geven deze de vereiste toewijzingsgrootte op. Het type van de expressie kan impliciet worden omgezet naar het type int.

Omdat de grootte van een stacktoewijzing niet negatief kan zijn, is het een compilatiefout om het aantal items op te geven als een constant_expression die een negatieve waarde oplevert.

Tijdens runtime als het aantal items dat moet worden toegewezen een negatieve waarde is, is het gedrag niet gedefinieerd. Als deze nul is, wordt er geen toewijzing gemaakt en wordt de geretourneerde waarde door de implementatie gedefinieerd. Als er onvoldoende geheugen beschikbaar is om de items toe te wijzen, wordt er een System.StackOverflowException gegenereerd.

Wanneer er een stackalloc_initializer aanwezig is:

• Als unmanaged_type wordt weggelaten, wordt deze afgeleid uit de regels voor het beste gemeenschappelijke type (§12.6.3.16) voor de set stackalloc_element_initializers.
• Als constant_expression wordt weggelaten, wordt aangenomen dat het overeenkomt met het aantal stackalloc_element_initializers.
• Indien de constant_expression aanwezig is, moet deze gelijk zijn aan het aantal stackalloc_element_initializer's.

Elke stackalloc_element_initializer heeft een impliciete conversie naar unmanaged_type (§10,2). De stackalloc_element_initializerelementen in het toegewezen geheugen initialiseren in toenemende volgorde, beginnend met het element bij index nul. Als er geen stackalloc_initializeris, is de inhoud van het zojuist toegewezen geheugen niet gedefinieerd.

Als een stackalloc_expression zich rechtstreeks voordoet als de initialisatie-expressie van een local_variable_declaration (§13.6.2), waarbij de local_variable_type een type aanwijzer (§24.3) of afgeleid (var) is, is het resultaat van de stackalloc_expression een type T* aanwijzer (§24.9). In dit geval moet de stackalloc_expression in onveilige code worden weergegeven. Anders is het resultaat van een stackalloc_expression een exemplaar van het type Span<T>, waarbij T het unmanaged_typeis:

• Span<T> (§C.3) is een verwijzingstype (§16.2.3), dat een geheugenblok weergeeft, hier het blok dat door de stackalloc_expressionis toegewezen, als een indexeerbare verzameling getypte (T) items.
• De eigenschap Length van het resultaat retourneert het aantal toegewezen items.
• De indexeerder van het resultaat (§15,9) retourneert een variabele_referentie (§9,5) naar een item van het toegewezen blok en controleert het bereik.

Initialisaties voor stacktoewijzing zijn niet toegestaan in catch of finally blokken (§13.11).

Opmerking: er is geen manier om expliciet geheugen vrij te maken met behulp van stackalloc. eindnotitie

Alle stack-toegewezen geheugenblokken die zijn gemaakt tijdens de uitvoering van een functielid, worden automatisch verwijderd wanneer dat functielid terugkeert.

Behalve de stackalloc-operator biedt C# geen vooraf gedefinieerde constructies voor het beheren van niet-garbage verzameld geheugen. Dergelijke services worden doorgaans geleverd door ondersteunende klassebibliotheken of rechtstreeks vanuit het onderliggende besturingssysteem geïmporteerd.

voorbeeld van:

// Memory uninitialized
Span<int> span1 = stackalloc int[3];
// Memory initialized
Span<int> span2 = stackalloc int[3] { -10, -15, -30 };
// Type int is inferred
Span<int> span3 = stackalloc[] { 11, 12, 13 };
// Error; result is int*, not allowed in a safe context
var span4 = stackalloc[] { 11, 12, 13 };
// Error; no conversion from Span<int> to Span<long>
Span<long> span5 = stackalloc[] { 11, 12, 13 };
// Converts 11 and 13, and returns Span<long> 
Span<long> span6 = stackalloc[] { 11, 12L, 13 };
// Converts all and returns Span<long>
Span<long> span7 = stackalloc long[] { 11, 12, 13 };
// Implicit conversion of Span<T>
ReadOnlySpan<int> span8 = stackalloc int[] { 10, 22, 30 };
// Implicit conversion of Span<T>
Widget<double> span9 = stackalloc double[] { 1.2, 5.6 };

public class Widget<T>
{
    public static implicit operator Widget<T>(Span<double> sp) { return null; }
}

In het geval van span8resulteert stackalloc in een Span<int>, die wordt geconverteerd door een impliciete operator naar ReadOnlySpan<int>. Op dezelfde manier wordt voor span9het resulterende Span<double> geconverteerd naar het door de gebruiker gedefinieerde type Widget<double> met behulp van de conversie, zoals wordt weergegeven. einde voorbeeld

12.8.23 De naam van de operator

Een nameof_expression wordt gebruikt om de naam van een programma-entiteit te verkrijgen als een constante tekenreeks.

nameof_expression
    : 'nameof' '(' named_entity ')'
    ;
    
named_entity
    : named_entity_target ('.' identifier type_argument_list?)*
    ;
    
named_entity_target
    : simple_name
    | 'this'
    | 'base'
    | predefined_type 
    | qualified_alias_member
    ;

Omdat nameof geen trefwoord is, is een nameof_expression altijd syntactisch dubbelzinnig met een aanroep van de eenvoudige naam nameof. Omwille van compatibiliteitsredenen, als een naamzoekactie (§12.8.4) van de naam nameof slaagt, wordt de uitdrukking beschouwd als een aanroep-uitdrukking, ongeacht of de aanroep geldig is. Anders is het een nameof_expression.

Eenvoudige naam- en lidtoegangsopzoekingen worden uitgevoerd op de named_entity tijdens de compilatietijd, volgens de regels beschreven in §12.8.4 en §12.8.7. Wanneer de zoekactie die wordt beschreven in §12.8.4 en §12.8.7 echter een fout oplevert omdat een exemplaarlid in een statische context is gevonden, veroorzaakt een nameof_expression geen dergelijke fout.

Het is een compilatiefout voor een named_entity die een methodegroep aanduidt om een type_argument_listte hebben. Het is een compilatietijdfout als een named_entity_target het type dynamicheeft.

Een nameof_expression is een constante expressie van het type stringen heeft geen effect tijdens runtime. Het named_entity ervan wordt niet geëvalueerd en wordt genegeerd voor een definitieve toewijzingsanalyse (§9.4.4.22). De waarde is de laatste identificator van de named_entity vóór de optionele laatste type_argument_list, veranderd op de volgende manier:

• Het voorvoegsel "@", indien gebruikt, wordt verwijderd.
• Elke unicode_escape_sequence wordt omgezet in het bijbehorende Unicode-teken.
• Alle formatting_characters worden verwijderd.

Dit zijn dezelfde transformaties die worden toegepast in §6.4.3 bij het testen van gelijkheid tussen id's.

Voorbeeld: De volgende illustratie toont de resultaten van verschillende nameof expressies, ervan uitgaande dat een algemeen type List<T> binnen de System.Collections.Generic naamruimte is gedeclareerd.

using TestAlias = System.String;

class Program
{
    static void Main()
    {
        var point = (x: 3, y: 4);

        string n1 = nameof(System);                      // "System"
        string n2 = nameof(System.Collections.Generic);  // "Generic"
        string n3 = nameof(point);                       // "point"
        string n4 = nameof(point.x);                     // "x"
        string n5 = nameof(Program);                     // "Program"
        string n6 = nameof(System.Int32);                // "Int32"
        string n7 = nameof(TestAlias);                   // "TestAlias"
        string n8 = nameof(List<int>);                   // "List"
        string n9 = nameof(Program.InstanceMethod);      // "InstanceMethod"
        string n10 = nameof(Program.GenericMethod);      // "GenericMethod"
        string n11 = nameof(Program.NestedClass);        // "NestedClass"

        // Invalid
        // string x1 = nameof(List<>);            // Empty type argument list
        // string x2 = nameof(List<T>);           // T is not in scope
        // string x3 = nameof(GenericMethod<>);   // Empty type argument list
        // string x4 = nameof(GenericMethod<T>);  // T is not in scope
        // string x5 = nameof(int);               // Keywords not permitted
        // Type arguments not permitted for method group
        // string x6 = nameof(GenericMethod<Program>);
    }

    void InstanceMethod() { }

    void GenericMethod<T>()
    {
        string n1 = nameof(List<T>); // "List"
        string n2 = nameof(T);       // "T"
    }

    class NestedClass { }
}

Mogelijk verrassende delen van dit voorbeeld zijn de resolutie van nameof(System.Collections.Generic) naar alleen 'Algemeen' in plaats van de volledige naamruimte, en van nameof(TestAlias) naar 'TestAlias' in plaats van 'Tekenreeks'. einde voorbeeld

12.8.24 Anonieme methodeexpressies

Een anonymous_method_expression is een van de twee manieren om een anonieme functie te definiëren. Deze worden verder beschreven in §12.21.

12.9 Unaire operatoren

12.9.1 Algemeen

De +, -( ! logische negatie alleen §12.9.4 ), ~, , ^, ++, --cast en await operatoren worden de unaire operatoren genoemd.

Opmerking: de postfix null-forgiving operator (§12.8.9), !, vanwege zijn aard dat het alleen tijdens compilatietijd is en niet-overlaadbaar, wordt uitgesloten van de bovenstaande lijst. eindnotitie

unary_expression
    : primary_expression
    | '+' unary_expression
    | '-' unary_expression
    | logical_negation_operator unary_expression
    | '~' unary_expression
    | '^' unary_expression
    | pre_increment_expression
    | pre_decrement_expression
    | cast_expression
    | await_expression
    | pointer_indirection_expression    // unsafe code support
    | addressof_expression              // unsafe code support
    ;

pointer_indirection_expression (§24.6.2) en addressof_expression (§24.6.5) zijn alleen beschikbaar in onveilige code (§24).

Als de operand van een unary_expression het type compileertijd heeft dynamic, is deze dynamisch gebonden (§12.3.3). In dit geval:

• het type compilatietijd van de unary_expression is:
  • Index voor de index van de ^ eindoperator (§12.9.6)
  • dynamic voor alle andere unaire exploitanten; en
• de onderstaande oplossing vindt plaats tijdens runtime met behulp van het uitvoeringstype van de operand.

12.9.2 Unary plus operator

Voor een werking van het formulier +xwordt een unaire operator overbelastingsresolutie (§12.4.4) toegepast om een specifieke operator-implementatie te selecteren. De operand wordt geconverteerd naar het parametertype van de geselecteerde operator en het type van het resultaat is het retourtype van de operator. De vooraf gedefinieerde unaire plusoperators zijn:

int operator +(int x);
uint operator +(uint x);
long operator +(long x);
ulong operator +(ulong x);
float operator +(float x);
double operator +(double x);
decimal operator +(decimal x);

Voor elk van deze operators is het resultaat gewoon de waarde van de operand.

Opgeheven (§12.4.8) vormen van de vooraf gedefinieerde niet-opgeheven unaire plusoperatoren, die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.9.3 Unaire mintekenoperator

Voor een werking van het formulier –xwordt een unaire operator overbelastingsresolutie (§12.4.4) toegepast om een specifieke operator-implementatie te selecteren. De operand wordt geconverteerd naar het parametertype van de geselecteerde operator en het type van het resultaat is het retourtype van de operator. De vooraf gedefinieerde unaire mintekenoperators zijn:

• Negatie van gehele getallen:

  int operator –(int x);
  long operator –(long x);
  

  Het resultaat wordt berekend door X van nul af te trekken. Als de waarde van X de kleinste vertegenwoordigbare waarde is van het operandtype (−2¹ voor int of −2⁶³ voor long), is de wiskundige negatie van X niet zichtbaar binnen het operandtype. Als dit gebeurt binnen een checked context, wordt er een System.OverflowException gegenereerd; als deze zich in een unchecked context voordoet, is het resultaat de waarde van de operand en wordt de overloop niet gerapporteerd.

  Als de operand van de negatieoperator van het type uintis, wordt deze geconverteerd naar het type longen wordt het type van het resultaat long. Een uitzondering is de regel waarmee de int waarde −2147483648 (−2¹¹) kan worden geschreven als een letterlijk geheel getal voor decimalen (§6.4.5.3).

  Als de operand van de negatieoperator van het type ulongis, treedt er een compilatietijdfout op. Een uitzondering is de regel waarmee de long waarde −9223372036854775808 (−2⁶³) kan worden geschreven als een letterlijk decimaal geheel getal (§6.4.5.3)

• Negatie met drijvende komma:

  float operator –(float x);
  double operator –(double x);
  

  Het resultaat is de waarde van X waarbij het teken is omgekeerd. Als xNaNis, wordt het resultaat ook NaN.

• Decimale negatie

  decimal operator –(decimal x);
  

  Het resultaat wordt berekend door X van nul af te trekken. Decimaal negatie is gelijk aan het gebruik van de unaire min-operator van het type System.Decimal.

Opgeheven (§12.4.8) vormen van de onopgeheven, voorgedefinieerde unaire min-operatoren die hierboven zijn gedefinieerd, zijn ook voorgedefinieerd.

12.9.4 Logische negatieoperator

Voor een werking van het formulier !xwordt een unaire operator overbelastingsresolutie (§12.4.4) toegepast om een specifieke operator-implementatie te selecteren. De operand wordt geconverteerd naar het parametertype van de geselecteerde operator en het type van het resultaat is het retourtype van de operator. Er bestaat slechts één vooraf gedefinieerde logische negatieoperator:

bool operator !(bool x);

Deze operator berekent de logische negatie van de operand: Als de operand is true, wordt het resultaat false. Als de operand falseis, wordt het resultaat true.

Geheven (§12.4.8) vormen van de niet-geheven logische negatieoperator die hierboven is gedefinieerd, zijn eveneens vooraf gedefinieerd.

Opmerking: De voorvoegseloperator voor logische negatie en de postfix null-forgiving operator (§12.8.9) worden weliswaar door hetzelfde lexicale token (!) uitgebeeld, maar zijn verschillend. eindnotitie

12.9.5 Bitsgewijze complementoperator

Voor een werking van het formulier ~xwordt een unaire operator overbelastingsresolutie (§12.4.4) toegepast om een specifieke operator-implementatie te selecteren. De operand wordt geconverteerd naar het parametertype van de geselecteerde operator en het type van het resultaat is het retourtype van de operator. De vooraf gedefinieerde bitsgewijze complementoperators zijn:

int operator ~(int x);
uint operator ~(uint x);
long operator ~(long x);
ulong operator ~(ulong x);

Voor elk van deze operators is het resultaat van de bewerking het bitsgewijze complement van x.

Elk opsommingstype E impliciet de volgende bitsgewijze complementoperator biedt:

E operator ~(E x);

Het resultaat van het evalueren van ~x, waarbij X een expressie is van een opsommingstype E met een onderliggend type U, is precies hetzelfde als het evalueren van (E)(~(U)x), behalve dat de conversie naar E altijd wordt uitgevoerd alsof in een unchecked context (§12.8.20).

Geheven (§12.4.8) vormen van de niet-geheven vooraf gedefinieerde bitwise complementoperators die hierboven zijn gedefinieerd, zijn eveneens vooraf gedefinieerd.

12.9.6 Index van eindoperator

De unaire ^ operator wordt de index van de eindoperator genoemd (dit wordt ook wel de hat-operator genoemd). Deze operator is niet overbelast (§12.4.3) en er is één vooraf gedefinieerde operator:

Index operator ^(int x);

Het resultaat van een bewerking van het formulier ^x is een from-endwaarde Index (§18.2) die gelijk is aan het resultaat van de expressie:

new Index(x, true)

Net als bij de andere unary_expression kande operand een type compileertijd (dynamic§12.9.1) hebben en dynamisch gebonden zijn (§12.3.3). Het type compileertijd van het resultaat is altijd Index.

Een opgeheven (§12.4.8) vorm van de index vanaf de eindoperator is ook vooraf gedefinieerd.

12.9.7 Voorvoegsel verhogen en verlagen operators

pre_increment_expression
    : '++' unary_expression
    ;

pre_decrement_expression
    : '--' unary_expression
    ;

De operand van een voorvoegselverhoging of -degradatiebewerking moet een expressie zijn die is geclassificeerd als een variabele, een eigenschapstoegang of een indexeerfunctietoegang. Het resultaat van de bewerking is een waarde van hetzelfde type als de operand.

Als de operand van het voorvoegsel van een incrementele of decrementele bewerking een eigenschap of indexertoegang is, moet de eigenschap of indexer zowel een get- als een set-toegangsfunctie hebben. Als dit niet het geval is, treedt er een bindingstijdfout op.

De oplossing voor overbelasting van unaire operatoren (§12.4.4) wordt toegepast om een specifieke operator-implementatie te selecteren. Vooraf gedefinieerde ++- en -- operators bestaan voor de volgende typen: sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimalen een opsommingstype. De vooraf gedefinieerde ++ operators retourneren de waarde die wordt geproduceerd door 1 toe te voegen aan de operand en de vooraf gedefinieerde -- operators retourneren de waarde die wordt geproduceerd door 1 af te trekken van de operand. Als in een checked-context het resultaat van deze optelling of aftrekking buiten het bereik van het resultaattype valt en het resultaattype een integraal type of opsommingstype is, wordt er een System.OverflowException gegooid.

Er moet een impliciete conversie zijn van het retourtype van de geselecteerde unaire operator naar het type van de unary_expression, anders treedt er een compilatietijdfout op.

De runtime-verwerking van een voorvoegsel-increment- of decrementoperatie van de vorm ++x of --x bestaat uit de volgende stappen:

• Als x is geclassificeerd als een variabele:
  • x wordt geëvalueerd om de variabele te produceren.
  • De waarde van x wordt geconverteerd naar het operandtype van de geselecteerde operator en de operator wordt aangeroepen met deze waarde als argument.
  • De waarde die door de operator wordt geretourneerd, wordt geconverteerd naar het type x. De resulterende waarde wordt opgeslagen op de locatie die is opgegeven door de evaluatie van x en wordt het resultaat van de bewerking.
• Als x is geclassificeerd als een eigenschap of indexertoegang:
  • De exemplaarexpressie (als x niet staticis) en de lijst met argumenten (als x een indexeerfunctietoegang is) die aan x is gekoppeld, worden geëvalueerd en de resultaten worden gebruikt in de daaropvolgende aanroepen van de get- en set-toegangsmethodes.
  • De get-accessor van x wordt aangeroepen.
  • De waarde die door de get-accessor wordt geretourneerd, wordt geconverteerd naar het operandtype van de geselecteerde operator en de operator wordt aangeroepen met deze waarde als argument.
  • De waarde die door de operator wordt geretourneerd, wordt geconverteerd naar het type x. De set accessor van x wordt aangeroepen met deze waarde als waardeargument.
  • Deze waarde wordt ook het resultaat van de bewerking.

De operators ++ en -- ondersteunen ook postfix-notatie (§12.8.16). Het resultaat van x++ of x-- is de waarde van x vóór de bewerking, terwijl het resultaat van ++x of --x de waarde is van x na de bewerking. In beide gevallen heeft x zelf dezelfde waarde na de bewerking.

Een operator ++- of operator ---implementatie kan worden aangeroepen met behulp van een achtervoegsel- of voorvoegselnotatie. Het is niet mogelijk om afzonderlijke operator-implementaties te hebben voor de twee notaties.

Opgeheven (§12.4.8) vormen van de niet-opgeheven vooraf gedefinieerde voorvoegsel- en decrementoperatoren die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.9.8 Cast-expressies

Een cast_expression wordt gebruikt om expliciet een expressie te converteren naar een bepaald type.

cast_expression
    : '(' type ')' unary_expression
    ;

Een cast_expression van de vorm (T)E, waarin T een type is en E een unary_expressionis, voert een expliciete conversie uit (§10.3) van de waarde van E naar type T. Als er geen expliciete conversie bestaat van E naar T, treedt er een bindingstijdfout op. Anders is het resultaat de waarde die wordt geproduceerd door de expliciete conversie. Het resultaat wordt altijd geclassificeerd als een waarde, zelfs als E een variabele aangeeft.

De grammatica voor een cast_expression leidt tot bepaalde syntactische ambiguïteiten.

voorbeeld: de expressie (x)–y kan worden geïnterpreteerd als een cast_expression (een cast van –y om xte typen) of als een additive_expression gecombineerd met een parenthesized_expression (waarmee de waarde x – ywordt berekend). einde voorbeeld

Om cast_expression dubbelzinnigheden op te lossen, bestaat de volgende regel: Een reeks tokens (§6.4) tussen haakjes wordt beschouwd als het begin van een cast_expression alleen als ten minste één van de volgende waar is:

• De volgorde van tokens is de juiste grammatica voor een type, maar niet voor een expressie.
• De volgorde van tokens is de juiste grammatica voor een type en het token direct na de sluitende haakjes is het token "~", het token "!", het token "(", een identifier (§6.4.3), een letterlijk (§6.4.5), of een trefwoord (§6.4.4) met uitzondering van as en is.

De term "juiste grammatica" hierboven betekent alleen dat de reeks tokens voldoet aan de specifieke grammaticale productie. Het houdt in het bijzonder geen rekening met de werkelijke betekenis van eventuele samenstellende id's.

voorbeeld: als x en y id's zijn, is x.y de juiste grammatica voor een type, zelfs als x.y geen type aangeeft. einde voorbeeld

Opmerking: Uit de ondubbelzinnigheidsregel volgt dat, als x en y id's zijn, (x)y, (x)(y)en (x)(-y)cast_expressionzijn, maar (x)-y niet, zelfs niet als x een type identificeert. Als x echter een trefwoord is waarmee een vooraf gedefinieerd type (zoals int) wordt geïdentificeerd, worden alle vier de formulieren cast_expressions (omdat een dergelijk trefwoord geen expressie kan zijn). eindnotitie

12.9.9 Await-expressies

12.9.9.1 Algemeen

De operator await wordt gebruikt om de evaluatie van de omringende asynchrone functie op te schorten totdat de asynchrone bewerking die wordt vertegenwoordigd door de operand is voltooid.

await_expression
    : 'await' unary_expression
    ;

Een await_expression is alleen toegestaan in de hoofdtekst van een asynchrone functie (§15.14). Binnen de dichtstbijzijnde insluitende asynchrone functie vindt een await_expression niet plaats op deze plaatsen:

• Binnen een geneste (niet-asynchrone) anonieme functie
• Binnen het blok van een lock_statement
• In een anonieme functieconversie naar een expressiestructuurtype (§10.7.3)
• In een onveilige context

Opmerking: een await_expression kan niet voorkomen op de meeste plaatsen binnen een query_expression, omdat deze syntactisch zijn getransformeerd om niet-asynchrone lambda-expressies te gebruiken. eindnotitie

Binnen een asynchrone functie wordt await niet gebruikt als een available_identifier, hoewel de exacte aanduiding @await kan worden gebruikt. Er is dus geen syntactische dubbelzinnigheid tussen await_expressions en verschillende expressies met id's. Buiten asynchrone functies fungeert await als een normale id.

De operand van een await_expression wordt de taakgenoemd. Het vertegenwoordigt een asynchrone bewerking die al dan niet voltooid is op het moment dat de await_expression wordt geëvalueerd. Het doel van de operator await is het onderbreken van de uitvoering van de omhullende asynchrone functie totdat de afgewachte taak is voltooid en vervolgens het resultaat ervan verkrijgen.

12.9.9.2 Wachtbare expressies

De taak van een await_expression moet afwachting mogelijk maken. Een expressie t kan worden verwacht als een van de volgende bewaringen geldt:

• t is van het compilatietijdstype dynamic
• t heeft een toegankelijke instantie of extensiemethode met de naam GetAwaiter zonder parameters en zonder typeparameters, en een retourtype A waarvoor al het volgende van toepassing is:
  • A implementeert de interface System.Runtime.CompilerServices.INotifyCompletion (hierna bekend als INotifyCompletion voor beknoptheid)
  • A heeft een toegankelijke, leesbare instantieeigenschap IsCompleted van het type bool
  • A heeft een toegankelijke exemplaarmethode GetResult zonder parameters en geen typeparameters

Het doel van de GetAwaiter-methode is om een afwachter voor een taak te verkrijgen. Het type A wordt het afwachtertype genoemd voor de await-expressie.

Het doel van de eigenschap IsCompleted is om te bepalen of de taak al is voltooid. Zo ja, dan hoeft u de evaluatie niet op te schorten.

Het doel van de INotifyCompletion.OnCompleted methode is het registreren van een "vervolg" voor de taak; Een gemachtigde (van het type System.Action) die wordt aangeroepen zodra de taak is voltooid.

Het doel van de GetResult methode is het verkrijgen van het resultaat van de taak zodra deze is voltooid. Dit resultaat kan een succesvolle voltooiing zijn, mogelijk met een resultaatwaarde, of het kan een uitzondering zijn die wordt gegooid door de methode GetResult.

12.9.9.3 Classificatie van wachtexpressies

De expressie await t wordt op dezelfde manier geclassificeerd als de expressie (t).GetAwaiter().GetResult(). Als het retourtype van GetResult dus voidis, wordt de await_expression geclassificeerd als niets. Als het een niet-void retourtype Theeft, wordt de await_expression geclassificeerd als een waarde van het type T.

12.9.9.4 Runtime-evaluatie van wachtexpressies

Tijdens runtime wordt de expressie await t als volgt geëvalueerd:

• Een awaiter a wordt verkregen door de expressie (t).GetAwaiter()te evalueren.
• Een boolb wordt verkregen door de uitdrukking (a).IsCompletedte evalueren.
• Als b is false, hangt de evaluatie ervan af of a de interface-System.Runtime.CompilerServices.ICriticalNotifyCompletion implementeert (hierna bekend als ICriticalNotifyCompletion voor beknoptheid). Deze controle wordt uitgevoerd op het moment van binden; d.w.z., tijdens runtime als a het compileertijd type dynamicheeft, en anders tijdens compileertijd. Geef r de hervattingsdelegatie aan (§15.14):
  • Als a geen ICriticalNotifyCompletionimplementeert, wordt de expressie ((a) as INotifyCompletion).OnCompleted(r) geëvalueerd.
  • Als aICriticalNotifyCompletionimplementeert, wordt de expressie ((a) as ICriticalNotifyCompletion).UnsafeOnCompleted(r) geëvalueerd.
  • De evaluatie wordt vervolgens onderbroken en het besturingselement wordt teruggezet naar de huidige aanroeper van de asynchrone functie.
• Hetzij direct na (indien b is true) of bij latere aanroep van de hervattingsdelegatie (indien b is false), wordt de expressie (a).GetResult() geëvalueerd. Als er een waarde wordt geretourneerd, is die waarde het resultaat van de await_expression. Anders is het resultaat niets.

De implementatie van de interfacemethoden INotifyCompletion.OnCompleted en ICriticalNotifyCompletion.UnsafeOnCompleted moet ervoor zorgen dat de gedelegeerde r maximaal één keer wordt aangeroepen. Anders is het gedrag van de ingesloten asynchrone functie niet gedefinieerd.

12.10 Bereikoperator

De .. operator wordt de bereikoperator genoemd.

range_expression
    : unary_expression
    | unary_expression? '..' unary_expression?
    ;

De vooraf gedefinieerde bereikoperator is:

Range operator ..(Index x, Index y);

De bereikoperator is niet overbelast (§12.4.3).

Alle bereikexpressies worden behandeld als het formulier x..y, waarbij:

• x is de linkeroperand indien aanwezig, anders de expressie 0; en
• y is de juiste operand indien aanwezig, anders de expressie ^0.

Het resultaat van de bewerking is een Range waarde (§18.3) die gelijk is aan het resultaat van de expressie:

new Range(x, y)

Als een van beide operanden in een bereikexpressie het type compileertijd dynamicheeft, is de expressie dynamisch gebonden (§12.3.3).3. Het type compileertijd van het resultaat is altijd Range.

Een opgeheven (§12.4.8) vorm van de bereikoperator is ook vooraf gedefinieerd.

De bereikoperator is niet-associatief (§12.4.2).

12.11 Switch-expressie

Een switch_expression biedt switch-achtige semantiek in een expressiecontext.

switch_expression
    : range_expression
    | switch_expression 'switch' '{' switch_expression_arms? '}'
    ;

switch_expression_arms
    : switch_expression_arm (',' switch_expression_arm)* ','?
    ;

switch_expression_arm
    : pattern case_guard? '=>' switch_expression_arm_expression
    ;

switch_expression_arm_expression
    : expression
    ;

Er is een conversie van een switchexpressie (§10.2.18) van een switchexpressie naar een type T als er een impliciete conversie is van elke switch_expression_arm_expression van elk van de switch_expression_armvan elke switchexpressie naar T.

Als een switchexpressie niet onderhevig is aan een conversie van een switchexpressie,

• Het type van de switch_expression is het meest voorkomende type §12.6.3.16) van de switch_expression_arm_expressionvan de switch_expression_arms, als een dergelijk type bestaat en elke switch_expression_arm_expression impliciet kan worden geconverteerd naar dat type.
• Het is een fout als er geen dergelijk type bestaat.

Het is een fout als het patroon van een switch_expression_arm het resultaat niet kan beïnvloeden, omdat een eerder patroon en een bewaker altijd overeenkomen.

Een switchexpressie wordt als volledig beschouwd als elke waarde van de invoer wordt verwerkt door ten minste één arm van de switchexpressie. De compiler levert een waarschuwing op als een switchexpressie niet volledig is. Tijdens runtime is het resultaat van de switch_expression de waarde van de expressie van de eerste switch_expression_arm waarvoor de expressie aan de linkerkant van de switch_expression overeenkomt met het patroon van de switch_expression_arm, en waarvoor de case_guard van de switch_expression_arm, indien aanwezig, resulteert in true. Als er geen dergelijke switch_expression_arm is, genereert de switch_expression een exemplaar van de uitzondering System.Runtime.CompilerServices.SwitchExpressionException.

Voorbeeld: Met het volgende worden waarden van een enum geconverteerd die visuele aanwijzingen op een onlinekaart vertegenwoordigen naar de bijbehorende kardinaliteitsrichtingen:

static Orientation ToOrientation(Direction direction) => direction switch
{
    Direction.Up    => Orientation.North,
    Direction.Right => Orientation.East,
    Direction.Down  => Orientation.South,
    Direction.Left  => Orientation.West,
    _ => throw new ArgumentOutOfRangeException(direction.ToString()),
};

public enum Direction
{
    Up,
    Down,
    Right,
    Left
}

public enum Orientation
{
    North,
    South,
    East,
    West
}

einde voorbeeld

12.12 Rekenkundige operatoren

12.12.1 Algemeen

De operatoren *, /, %, +en - worden de rekenkundige operatoren genoemd.

multiplicative_expression
    : switch_expression
    | multiplicative_expression '*' switch_expression
    | multiplicative_expression '/' switch_expression
    | multiplicative_expression '%' switch_expression
    ;

additive_expression
    : multiplicative_expression
    | additive_expression '+' multiplicative_expression
    | additive_expression '-' multiplicative_expression
    ;

Als een operand van een rekenkundige operator het type compileertijd heeft dynamic, is de expressie dynamisch gebonden (§12.3.3). In dit geval is het type compilatietijd van de expressie dynamicen vindt de onderstaande resolutie plaats tijdens runtime met behulp van het runtimetype van die operanden met het type compileertijd dynamic.

12.12.2 Vermenigvuldigingsoperator

Voor een werking van het formulier x * ywordt overbelastingsresolutie van binaire operatoren (§12.4.5) toegepast om een specifieke operator-implementatie te selecteren. De operanden worden geconverteerd naar de parametertypen van de geselecteerde operator en het type van het resultaat is het retourtype van de operator.

De vooraf gedefinieerde vermenigvuldigingsoperatoren worden hieronder vermeld. De operators berekenen allemaal het product van x en y.

• Vermenigvuldiging van gehele getallen:

  int operator *(int x, int y);
  uint operator *(uint x, uint y);
  long operator *(long x, long y);
  ulong operator *(ulong x, ulong y);
  

  In een checked context, als het product buiten het bereik van het resultaattype valt, wordt er een System.OverflowException opgeworpen. In een unchecked context worden overlopen niet gerapporteerd en worden belangrijke bovenste bits buiten het bereik van het resultaattype genegeerd.

• Vermenigvuldiging van zwevende komma

  float operator *(float x, float y);
  double operator *(double x, double y);
  

  Het product wordt berekend volgens de regels van IEC 60559 rekenkundige berekeningen. De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel zijn x en y positieve eindige waarden. z is het resultaat van x * y, afgerond op de dichtstbijzijnde vertegenwoordigbare waarde. Als de grootte van het resultaat te groot is voor het doeltype, z oneindig is. Vanwege afronding kan z nul zijn, ook al is x noch y nul.

  	+y	-y	+0	-0	+∞	-∞	NaN
  +x	+z	-z	+0	-0	+∞	-∞	NaN
  -x	-z	+z	-0	+0	-∞	+∞	NaN
  +0	+0	-0	+0	-0	NaN	NaN	NaN
  -0	-0	+0	-0	+0	NaN	NaN	NaN
  +∞	+∞	-∞	NaN	NaN	+∞	-∞	NaN
  -∞	-∞	+∞	NaN	NaN	-∞	+∞	NaN
  NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN

  (Tenzij anders vermeld, betekent het gebruik van "" in de tabellen met drijvende komma in §12.12.12.6 het gebruik van "+" de waarde positief is; het gebruik van "-" betekent dat de waarde negatief is; en het ontbreken van een teken betekent dat de waarde positief of negatief kan zijn of geen teken heeft (NaN).)

• Decimale vermenigvuldiging:

  decimal operator *(decimal x, decimal y);
  

  Als de grootte van de resulterende waarde te groot is om weer te geven in de decimale notatie, wordt er een System.OverflowException gegenereerd. Vanwege afronding kan het resultaat nul zijn, ook al is geen operand nul. De schaal van het resultaat, vóór afronding, is gelijk aan de som van de schalen van de twee operanden. Decimale vermenigvuldiging is gelijk aan het gebruik van de vermenigvuldigingsoperator van het type System.Decimal.

Opgeheven (§12.4.8) vormen van de onverheven vooraf gedefinieerde vermenigvuldigingsoperatoren die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.12.3 Operator Divisie

Voor een werking van het formulier x / ywordt overbelastingsresolutie van binaire operatoren (§12.4.5) toegepast om een specifieke operator-implementatie te selecteren. De operanden worden geconverteerd naar de parametertypen van de geselecteerde operator en het type van het resultaat is het retourtype van de operator.

Hieronder vindt u de vooraf gedefinieerde divisieoperators. De operators berekenen allemaal het quotiënt van x en y.

• Deling van gehele getallen:

  int operator /(int x, int y);
  uint operator /(uint x, uint y);
  long operator /(long x, long y);
  ulong operator /(ulong x, ulong y);
  

  Als de waarde van de rechteroperand nul is, wordt er een System.DivideByZeroException gegooid.

  De divisie rondt het resultaat af op nul. De absolute waarde van het resultaat is dus het grootst mogelijke gehele getal dat kleiner is dan of gelijk is aan de absolute waarde van het quotiënt van de twee operanden. Het resultaat is nul of positief wanneer de twee operanden hetzelfde teken en nul of negatief hebben wanneer de twee operanden tegengestelde tekens hebben.

  Als de linkeroperand de kleinste vertegenwoordigbare int of long waarde is en de rechteroperand –1is, treedt er een overloop op. In een checked context wordt hierdoor een System.ArithmeticException (of een subklasse daarvan) opgeworpen. In een unchecked-context ligt het aan de implementatie of een System.ArithmeticException (of een subklasse daarvan) wordt geworpen of dat de overloop niet gerapporteerd wordt, met als resulterende waarde die van de linkeroperand.

• Deling met drijvende komma

  float operator /(float x, float y);
  double operator /(double x, double y);
  

  Het quotiënt wordt berekend volgens de regels van IEC 60559-rekenkundige bewerkingen. De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel zijn x en y positieve eindige waarden. z is het resultaat van x / y, afgerond op de dichtstbijzijnde vertegenwoordigbare waarde.

  	+y	-y	+0	-0	+∞	-∞	NaN
  +x	+z	-z	+∞	-∞	+0	-0	NaN
  -x	-z	+z	-∞	+∞	-0	+0	NaN
  +0	+0	-0	NaN	NaN	+0	-0	NaN
  -0	-0	+0	NaN	NaN	-0	+0	NaN
  +∞	+∞	-∞	+∞	-∞	NaN	NaN	NaN
  -∞	-∞	+∞	-∞	+∞	NaN	NaN	NaN
  NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN

• Decimaal deling:

  decimal operator /(decimal x, decimal y);
  

  Als de waarde van de rechteroperand nul is, wordt er een System.DivideByZeroException gegooid. Als de grootte van de resulterende waarde te groot is om weer te geven in de decimale notatie, wordt er een System.OverflowException gegenereerd. Vanwege afronding kan het resultaat nul zijn, ook al is de eerste operand niet nul. De schaal van het resultaat, vóór afronding, is de dichtstbijzijnde schaal naar de voorkeursschaal die een resultaat behoudt dat gelijk is aan het exacte resultaat. De voorkeursschaal is de schaal van x minder de schaal van y.

  Decimaal deling is gelijk aan het gebruik van de delingsoperator van het type System.Decimal.

Opgeheven (§12.4.8) vormen van de niet-opgeheven vooraf gedefinieerde divisieoperators die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

Operator 12.12.4 Rest

Voor een werking van het formulier x % ywordt overbelastingsresolutie van binaire operatoren (§12.4.5) toegepast om een specifieke operator-implementatie te selecteren. De operanden worden geconverteerd naar de parametertypen van de geselecteerde operator en het type van het resultaat is het retourtype van de operator.

De vooraf gedefinieerde restoperators worden hieronder weergegeven. De operators berekenen allemaal de rest van de deling tussen x en y.

• Rest van een geheel getal

  int operator %(int x, int y);
  uint operator %(uint x, uint y);
  long operator %(long x, long y);
  ulong operator %(ulong x, ulong y);
  

  Het resultaat van x % y is de waarde die wordt geproduceerd door x – (x / y) * y. Als y nul is, wordt er een System.DivideByZeroException opgeworpen.

  Als de linkeroperand de kleinste int of long waarde is en de rechteroperand –1is, wordt er een System.OverflowException gegenereerd als en alleen als x / y een uitzondering zou genereren.

• Rest van drijvende komma:

  float operator %(float x, float y);
  double operator %(double x, double y);
  

  De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel zijn x en y positieve eindige waarden. z is het resultaat van x % y en wordt berekend als x – n * y, waarbij n het grootst mogelijke gehele getal is dat kleiner is dan of gelijk is aan x / y. Deze methode voor het berekenen van de rest is vergelijkbaar met de methode die wordt gebruikt voor gehele getallen, maar verschilt van de IEC 60559-definitie (waarbij n het gehele getal is dat het dichtst bij x / yligt).

  	+y	-y	+0	-0	+∞	-∞	NaN
  +x	+z	+z	NaN	NaN	+x	+x	NaN
  -x	-z	-z	NaN	NaN	-x	-x	NaN
  +0	+0	+0	NaN	NaN	+0	+0	NaN
  -0	-0	-0	NaN	NaN	-0	-0	NaN
  +∞	NaN	NaN	NaN	NaN	NaN	NaN	NaN
  -∞	NaN	NaN	NaN	NaN	NaN	NaN	NaN
  NaN	NaN	NaN	NaN	NaN	NaN	NaN	NaN

• Decimale restwaarde

  decimal operator %(decimal x, decimal y);
  

  Als de waarde van de rechteroperand nul is, wordt er een System.DivideByZeroException gegooid. Het is implementatie-afhankelijk wanneer een System.ArithmeticException (of een subklasse daarvan) wordt opgeworpen. Een conforme implementatie genereert geen uitzondering voor x % y in elk geval wanneer x / y geen uitzondering genereert. De schaal van het resultaat, vóór afronding, is de grotere schaal van de twee operanden en het teken van het resultaat is, indien niet-nul, gelijk aan dat van x.

  Decimale rest is gelijk aan het gebruik van de restoperator van type System.Decimal.

  Opmerking: deze regels zorgen ervoor dat voor alle typen het resultaat nooit het tegenovergestelde teken van de linkeroperand heeft. eindnotitie

Opgetilde (§12.4.8) vormen van de niet-opgetilde vooraf gedefinieerde restoperators die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.12.5 Optellen operator

Voor een werking van het formulier x + ywordt overbelastingsresolutie van binaire operatoren (§12.4.5) toegepast om een specifieke operator-implementatie te selecteren. De operanden worden geconverteerd naar de parametertypen van de geselecteerde operator en het type van het resultaat is het retourtype van de operator.

De vooraf gedefinieerde toevoegingsoperatoren worden hieronder vermeld. Voor numerieke en opsommingstypen berekenen de vooraf gedefinieerde opteloperators de som van de twee operanden. Wanneer een of beide operanden van het type stringzijn, voegen de vooraf gedefinieerde opteloperators de tekenreeksweergave van de operanden samen.

• Optellen van gehele getallen:

  int operator +(int x, int y);
  uint operator +(uint x, uint y);
  long operator +(long x, long y);
  ulong operator +(ulong x, ulong y
  

  In een checked-context, als de som buiten het bereik van het resultaattype valt, wordt er een System.OverflowException geworpen. In een unchecked context worden overlopen niet gerapporteerd en worden belangrijke bovenste bits buiten het bereik van het resultaattype genegeerd.

• Toevoeging van drijvende komma:

  float operator +(float x, float y);
  double operator +(double x, double y);
  

  De som wordt berekend volgens de regels van IEC 60559-rekenkundige berekeningen. De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel zijn x en y niet-nul eindige waarden en is z het resultaat van x + y. Als x en y dezelfde grootte maar tegengestelde tekens hebben, is z positief nul. Als x + y te groot is om aan te geven in het doeltype, is z een oneindigheid met hetzelfde teken als x + y.

  	y	+0	-0	+∞	-∞	NaN
  x	z	x	x	+∞	-∞	NaN
  +0	y	+0	+0	+∞	–∞	NaN
  -0	y	+0	-0	+∞	-∞	NaN
  +∞	+∞	+∞	+∞	+∞	NaN	NaN
  -∞	-∞	-∞	-∞	NaN	-∞	NaN
  NaN	NaN	NaN	NaN	NaN	NaN	NaN

• Decimaal optellen:

  decimal operator +(decimal x, decimal y);
  

  Als de grootte van de resulterende waarde te groot is om weer te geven in de decimale notatie, wordt er een System.OverflowException gegenereerd. De schaal van het resultaat, voordat het wordt afgerond, is de grotere schaal van de twee operanden.

  Decimaal optellen komt overeen met het gebruik van de optellingsoperator van het type System.Decimal.

• Opsommingstoevoeging. Elk opsommingstype biedt impliciet de volgende vooraf gedefinieerde operators, waarbij E het enumtype is en U het onderliggende type Eis:

  E operator +(E x, U y);
  E operator +(U x, E y);
  

  Tijdens runtime worden deze operators exact geëvalueerd als (E)((U)x + (U)y).

• Tekenreekssamenvoeging:

  string operator +(string x, string y);
  string operator +(string x, object y);
  string operator +(object x, string y);
  

  Deze overbelastingen van de binaire +-operator voeren tekenreekssamenvoeging uit. Als een operand van tekenreekssamenvoeging nullis, wordt een lege tekenreeks vervangen. Anders wordt elke niet-string operand geconverteerd naar de tekenreeksweergave door de virtuele ToString methode aan te roepen die is overgenomen van het type object. Als ToStringnullretourneert, wordt een lege tekenreeks vervangen.

  voorbeeld van:

  class Test
  {
      static void Main()
      {
          string s = null;
          Console.WriteLine("s = >" + s + "<");  // Displays s = ><
  
          int i = 1;
          Console.WriteLine("i = " + i);         // Displays i = 1
  
          float f = 1.2300E+15F;
          Console.WriteLine("f = " + f);         // Displays f = 1.23E+15
  
          decimal d = 2.900m;
          Console.WriteLine("d = " + d);         // Displays d = 2.900
     }
  }
  

  De uitvoer die in de opmerkingen wordt weergegeven, is het typische resultaat van een US-English systeem. De exacte uitvoer kan afhankelijk zijn van de regionale instellingen van de uitvoeringsomgeving. De operator voor tekenreekssamenvoeging gedraagt zich in elk geval op dezelfde manier, maar de ToString methoden die impliciet worden aangeroepen tijdens de uitvoering, kunnen worden beïnvloed door regionale instellingen.

  einde voorbeeld

  Het resultaat van de tekenreekssamenvoegingsoperator is een string die bestaat uit de tekens van de linkeroperand, gevolgd door de tekens van de rechteroperand. De operator voor tekenreekssamenvoeging retourneert nooit een null waarde. Er kan een System.OutOfMemoryException worden geworpen als er onvoldoende geheugen beschikbaar is om de resulterende tekenreeks toe te wijzen.

• Gedelegeerde combinatie. Elk type gemachtigde biedt impliciet de volgende vooraf gedefinieerde operator, waarbij D het type gedelegeerde is:

  D operator +(D x, D y);
  

  Als de eerste operand nullis, is het resultaat van de bewerking de waarde van de tweede operand (zelfs als dat ook null). Als de tweede operand nullis, is het resultaat van de bewerking de waarde van de eerste operand. Anders is het resultaat van de bewerking een nieuw gemachtigde exemplaar waarvan de aanroeplijst bestaat uit de elementen in de aanroeplijst van de eerste operand, gevolgd door de elementen in de aanroeplijst van de tweede operand. Dit betekent dat de aanroepenlijst van de resulterende delegate de concatenatie is van de aanroepenlijsten van de twee operanden.

  Opmerking: Zie §12.12.6 en §21.6 voor voorbeelden van combinatie van gemachtigden. Omdat System.Delegate geen gemachtigdentype is, is operator + niet gedefinieerd. eindnotitie

Opgeheven (§12.4.8) vormen van de niet-opgeheven vooraf gedefinieerde toevoegingsoperators zijn ook vooraf gedefinieerd.

12.12.6 Aftrekkingsoperator

Voor een werking van het formulier x – ywordt overbelastingsresolutie van binaire operatoren (§12.4.5) toegepast om een specifieke operator-implementatie te selecteren. De operanden worden geconverteerd naar de parametertypen van de geselecteerde operator en het type van het resultaat is het retourtype van de operator.

Hieronder vindt u de vooraf gedefinieerde aftrekkingsoperators. De operators trekken allemaal y van xaf.

• Aftrekken van gehele getallen

  int operator –(int x, int y);
  uint operator –(uint x, uint y);
  long operator –(long x, long y);
  ulong operator –(ulong x, ulong y
  

  In een checked context, als het verschil buiten het bereik van het resultaattype valt, wordt een System.OverflowException geworpen. In een unchecked context worden overlopen niet gerapporteerd en worden belangrijke bovenste bits buiten het bereik van het resultaattype genegeerd.

• Aftrekken van drijvende komma:

  float operator –(float x, float y);
  double operator –(double x, double y);
  

  Het verschil wordt berekend volgens de regels van IEC 60559 rekenkundige berekeningen. De volgende tabel bevat de resultaten van alle mogelijke combinaties van niet-nulwaarden, nullen, infiniteiten en NaN's. In de tabel zijn x en y niet-nul eindige waarden en is z het resultaat van x – y. Als x en y gelijk zijn, is z positief nul. Als x – y te groot is om aan te geven in het doeltype, is z een oneindigheid met hetzelfde teken als x – y.

  	y	+0	-0	+∞	-∞	NaN
  x	z	x	x	-∞	+∞	NaN
  +0	-y	+0	+0	-∞	+∞	NaN
  -0	-y	-0	+0	-∞	+∞	NaN
  +∞	+∞	+∞	+∞	NaN	+∞	NaN
  -∞	-∞	-∞	-∞	-∞	NaN	NaN
  NaN	NaN	NaN	NaN	NaN	NaN	NaN

  (In de bovenstaande tabel geven de -y vermeldingen de negatie van yaan, niet dat de waarde negatief is.)

• Decimaal aftrekken:

  decimal operator –(decimal x, decimal y);
  

  Als de grootte van de resulterende waarde te groot is om weer te geven in de decimale notatie, wordt er een System.OverflowException gegenereerd. De schaal van het resultaat, voordat het wordt afgerond, is de grotere schaal van de twee operanden.

  Decimaal aftrekken is gelijk aan het gebruik van de aftrekkingsoperator van het type System.Decimal.

• Aftrekken van een opsomming Elk opsommingstype biedt impliciet de volgende vooraf gedefinieerde operator, waarbij E het enumtype is en U het onderliggende type Eis:

  U operator –(E x, E y);
  

  Deze operator wordt op dezelfde wijze geëvalueerd als (U)((U)x – (U)y). Met andere woorden, de operator berekent het verschil tussen de rangtelwaarden van x en y, en het type van het resultaat is het onderliggende type van de opsomming.

  E operator –(E x, U y);
  

  Deze operator wordt op dezelfde wijze geëvalueerd als (E)((U)x – y). Met andere woorden, de operator trekt een waarde af van het onderliggende type van de opsomming, wat resulteert in een waarde van de opsomming.

• Verwijdering van de afgevaardigde. Elk type gemachtigde biedt impliciet de volgende vooraf gedefinieerde operator, waarbij D het type gedelegeerde is:

  D operator –(D x, D y);
  

  De semantiek is als volgt:

  • Als de eerste operand nullis, wordt het resultaat van de bewerking null.
  • Als de tweede operand nullis, is het resultaat van de bewerking de waarde van de eerste operand.
  • Anders vertegenwoordigen beide operanden niet-lege aanroeplijsten (§21.2).
    • Als de lijsten gelijk zijn, zoals bepaald door de gemachtigde gelijkheidsoperator (§12.14.9), is nullhet resultaat van de bewerking .
    • Anders is het resultaat van de bewerking een nieuwe aanroeplijst die bestaat uit de lijst van de eerste operand met de vermeldingen van de tweede operand die uit de lijst zijn verwijderd, mits de lijst van de tweede operand een sublijst van de eerste operand is. (Om gelijkheid in sublijsten te bepalen, worden overeenkomende vermeldingen vergeleken met de operator voor gedelegeerde gelijkheid.) Als de lijst van de tweede operand overeenkomt met meerdere sublijsten met aaneengesloten vermeldingen in de lijst van de eerste operand, wordt de laatste overeenkomende sublijst met aaneengesloten items verwijderd.
    • Anders is het resultaat van de bewerking de waarde van de linkeroperand.

  Geen van de lijsten van operanden (indien aanwezig) wordt in het proces gewijzigd.

  voorbeeld van:

  delegate void D(int x);
  
  class C
  {
      public static void M1(int i) { ... }
      public static void M2(int i) { ... }
  }
  
  class Test
  {
      static void Main()
      {
          D cd1 = new D(C.M1);
          D cd2 = new D(C.M2);
          D list = null;
  
          list = null - cd1;                             // null
          list = (cd1 + cd2 + cd2 + cd1) - null;         // M1 + M2 + M2 + M1
          list = (cd1 + cd2 + cd2 + cd1) - cd1;          // M1 + M2 + M2
          list = (cd1 + cd2 + cd2 + cd1) - (cd1 + cd2);  // M2 + M1
          list = (cd1 + cd2 + cd2 + cd1) - (cd2 + cd2);  // M1 + M1
          list = (cd1 + cd2 + cd2 + cd1) - (cd2 + cd1);  // M1 + M2
          list = (cd1 + cd2 + cd2 + cd1) - (cd1 + cd1);  // M1 + M2 + M2 + M1
          list = (cd1 + cd2 + cd2 + cd1) - (cd1 + cd2 + cd2 + cd1);  // null
      }
  }
  

  einde voorbeeld

Opgeheven (§12.4.8) vormen van de vooraf gedefinieerde niet-verheven aftrekkingsoperators die hierboven zijn gedefinieerd, zijn eveneens vooraf gedefinieerd.

12.13 Shift-operatoren

De operators << en >> worden gebruikt om bitverschuifbewerkingen uit te voeren.

shift_expression
    : additive_expression
    | shift_expression '<<' additive_expression
    | shift_expression right_shift additive_expression
    ;

Als een operand van een shift_expression het type compileertijd heeft dynamic, is de expressie dynamisch gebonden (§12.3.3). In dit geval is het type compilatietijd van de expressie dynamicen vindt de onderstaande resolutie plaats tijdens runtime met behulp van het runtimetype van die operanden met het type compileertijd dynamic.

Voor een werking van het formulier x << count of x >> countwordt de overbelastingsresolutie van binaire operatoren (§12.4.5) toegepast om een specifieke operator-implementatie te selecteren. De operanden worden geconverteerd naar de parametertypen van de geselecteerde operator en het type van het resultaat is het retourtype van de operator.

Bij het declareren van een overbelaste ploegendienstoperator moet het type van de eerste operand altijd de klasse of struct zijn die de declaratie van de operator bevat en het type van de tweede operand altijd int.

De vooraf gedefinieerde shiftoperators worden hieronder weergegeven.

• Naar links verschuiven:

  int operator <<(int x, int count);
  uint operator <<(uint x, int count);
  long operator <<(long x, int count);
  ulong operator <<(ulong x, int count);
  

  De operator << verschuift x naar links met een aantal bits, zoals beschreven in de onderstaande uitleg.

  De bits met hoge volgorde buiten het bereik van het resultaattype van x worden verwijderd, de resterende bits worden naar links verplaatst en de lege bitposities met lage volgorde worden ingesteld op nul.

• Naar rechts gaan:

  int operator >>(int x, int count);
  uint operator >>(uint x, int count);
  long operator >>(long x, int count);
  ulong operator >>(ulong x, int count);
  

  De operator >> verschuift x naar rechts door een aantal bits dat is berekend, zoals hieronder wordt beschreven.

  Wanneer x van het type int of longis, worden de bits met lage volgorde van x verwijderd, worden de resterende bits naar rechts verplaatst en worden de lege bitposities in hoge volgorde ingesteld op nul als x niet-negatief is en ingesteld op een als x negatief is.

  Wanneer x van het type uint of ulongis, worden de bits met lage volgorde van x verwijderd, worden de resterende bits naar rechts verplaatst en worden de lege bitposities in hoge volgorde ingesteld op nul.

Voor de vooraf gedefinieerde operators wordt het aantal bits dat moet worden verplaatst als volgt berekend:

• Wanneer het type xint of uintis, wordt het schuifgetal gegeven door de laagste vijf bits van count. Met andere woorden, het aantal diensten wordt berekend op basis van count & 0x1F.
• Wanneer het type van xlong of ulongis, wordt het aantal verschuivingen gegeven door de lage order zes bits van count. Met andere woorden, het aantal diensten wordt berekend op basis van count & 0x3F.

Als het resulterende aantal diensten nul is, retourneren de shiftoperators gewoon de waarde van x.

Shift-bewerkingen veroorzaken nooit overflow en geven dezelfde resultaten in gecontroleerde en zonder controle contexten.

Wanneer de linkeroperand van de operator >> van een getekend integraal type is, voert de operator een rekenkundige verschuiving naar rechts uit, waarbij de waarde van de meest significante bit (de tekenbit) van de operand wordt doorgegeven aan de hoogste lege bitposities. Wanneer de linkeroperand van de operator >> van een niet-ondertekend integraal type is, voert de operator een logische verschuiving naar rechts uit, waarbij bitposities van de hoogste orde altijd op nul worden ingesteld. Om de omgekeerde bewerking uit te voeren die wordt afgeleid uit het operandtype, kunnen expliciete casts worden gebruikt.

voorbeeld: als x een variabele van het type intis, wordt met de bewerking unchecked ((int)((uint)x >> y)) een logische verschuiving van xuitgevoerd. einde voorbeeld

Opgeheven (§12.4.8) vormen van de niet-opgeheven, vooraf gedefinieerde shift-operatoren die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.14 Relationele en typetestoperators

12.14.1 Algemeen

De operators ==, !=, <, >, <=, >=, isen as worden de operatoren voor relationele en typetests genoemd.

relational_expression
    : shift_expression
    | relational_expression '<' shift_expression
    | relational_expression '>' shift_expression
    | relational_expression '<=' shift_expression
    | relational_expression '>=' shift_expression
    | relational_expression 'is' type
    | relational_expression 'is' pattern
    | relational_expression 'as' type
    ;

equality_expression
    : relational_expression
    | equality_expression '==' relational_expression
    | equality_expression '!=' relational_expression
    ;

Opmerking: Het zoeken naar de juiste operand van de operator is moet eerst worden getest als een typeen vervolgens als een expressie die meerdere tokens kan omvatten. In het geval dat de operand een expressie is, moet de patroonexpressie ten minste zo hoog zijn als shift_expression. eindnotitie

Opmerking: er is een ambiguïteit tussen het type en constant_pattern in een relational_expression aan de rechterkant van is; een van beide kan een geldige parsering van een gekwalificeerde id zijn. In dat geval is het alleen opgelost als het niet kan worden verbonden als een type (voor compatibiliteit met eerdere versies van de taal), wordt het omgezet in het eerste gevonden (wat een constante of een type moet zijn). Deze dubbelzinnigheid is alleen aan de rechterkant van een dergelijke expressie aanwezig.

De is operator wordt beschreven in §12.14.12 en de as operator wordt beschreven in §12.14.13.

De operatoren ==, !=, <, >, <= en >= zijn vergelijkingsoperatoren.

Als een default_literal (§12.8.21) wordt gebruikt als operand van een <, >, <=of >= operator, treedt er een compilatietijdfout op. Als een default_literal wordt gebruikt als beide operanden van een ==- of !=-operator, treedt er een compilatietijdfout op. Als een default_literal wordt gebruikt als de linkeroperand van de operator is of as, treedt er een compilatietijdfout op.

Als een operand van een vergelijkingsoperator het type compileertijd heeft dynamic, is de expressie dynamisch gebonden (§12.3.3). In dit geval is het compile-tijdtype van de expressie dynamic, en zal de hieronder beschreven resolutie plaatsvinden tijdens de uitvoertijd met behulp van het uitvoertijdtype van die operanden die het compile-tijdtype dynamichebben.

Voor een werking van het formulier x «op» y, waarbij «op» een vergelijkingsoperator is, wordt overbelastingsresolutie (§12.4.5) toegepast om een specifieke operator-implementatie te selecteren. De operanden worden geconverteerd naar de parametertypen van de geselecteerde operator en het type van het resultaat is het retourtype van de operator. Als beide operanden van een equality_expression de letterlijke null zijn, wordt de overbelastingsresolutie niet uitgevoerd en wordt de expressie geëvalueerd tot een constante waarde van true of false, afhankelijk van of de operator == of !=is.

De vooraf gedefinieerde vergelijkingsoperatoren worden beschreven in de volgende subclauses. Alle vooraf gedefinieerde vergelijkingsoperatoren retourneren een resultaat van het type bool, zoals beschreven in de volgende tabel.

12.14.2 Vergelijkingsoperatoren voor gehele getallen

De vooraf gedefinieerde vergelijkingsoperatoren voor gehele getallen zijn:

bool operator ==(int x, int y);
bool operator ==(uint x, uint y);
bool operator ==(long x, long y);
bool operator ==(ulong x, ulong y);

bool operator !=(int x, int y);
bool operator !=(uint x, uint y);
bool operator !=(long x, long y);
bool operator !=(ulong x, ulong y);

bool operator <(int x, int y);
bool operator <(uint x, uint y);
bool operator <(long x, long y);
bool operator <(ulong x, ulong y);

bool operator >(int x, int y);
bool operator >(uint x, uint y);
bool operator >(long x, long y);
bool operator >(ulong x, ulong y);

bool operator <=(int x, int y);
bool operator <=(uint x, uint y);
bool operator <=(long x, long y);
bool operator <=(ulong x, ulong y);

bool operator >=(int x, int y);
bool operator >=(uint x, uint y);
bool operator >=(long x, long y);
bool operator >=(ulong x, ulong y);

Elk van deze operatoren vergelijkt de numerieke waarden van de twee gehele getallen en retourneert een bool waarde die aangeeft of de specifieke relatie true of falseis.

Opgeheven (§12.4.8) vormen van de niet-opgeheven vooraf gedefinieerde vergelijkingsoperatoren voor gehele getallen die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.14.3 Vergelijkingsoperatoren voor drijvende komma

De vooraf gedefinieerd kommagetalvergelijkingsoperatoren zijn:

bool operator ==(float x, float y);
bool operator ==(double x, double y);

bool operator !=(float x, float y);
bool operator !=(double x, double y);

bool operator <(float x, float y);
bool operator <(double x, double y);

bool operator >(float x, float y);
bool operator >(double x, double y);

bool operator <=(float x, float y);
bool operator <=(double x, double y);

bool operator >=(float x, float y);
bool operator >=(double x, double y);

De operators vergelijken de operanden volgens de regels van de IEC 60559-standaard:

Als een van beide operanden NaN is, wordt het resultaat false voor alle operators, met uitzondering van !=, waarvoor het resultaat trueis. Voor elke twee operanden produceert x != y altijd hetzelfde resultaat als !(x == y). Wanneer een of beide operanden NaN zijn, produceren de <, >, <= en >= operators echter niet dezelfde resultaten als de logische negatie van de omgekeerde operator.

voorbeeld: als een van x en y NaN is, wordt x < yfalse, maar !(x >= y) is true. einde voorbeeld

Wanneer geen van beide operanden NaN is, vergelijken de operators de waarden van de twee drijvendekommaoperanden met betrekking tot de volgorde

–∞ < –max < ... < –min < –0.0 == +0.0 < +min < ... < +max < +∞

waarbij min en max de kleinste en grootste positieve eindige waarden zijn die in de opgegeven drijvende-kommaformaat kunnen worden weergegeven. Belangrijke effecten van deze volgorde zijn:

• Negatieve en positieve nullen worden als gelijk beschouwd.
• Een negatieve oneindigheid wordt beschouwd als kleiner dan alle andere waarden, maar gelijk aan een andere negatieve oneindigheid.
• Een positief oneindigheid wordt beschouwd als groter dan alle andere waarden, maar gelijk aan een ander positief oneindigheid.

Gelifte (§12.4.8) vormen van de niet-gelifte vooraf gedefinieerde drijvende-punt vergelijkingsoperatoren die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.14.4 Decimale vergelijkingsoperatoren

De vooraf gedefinieerde operatoren voor decimaalvergelijking zijn:

bool operator ==(decimal x, decimal y);
bool operator !=(decimal x, decimal y);
bool operator <(decimal x, decimal y);
bool operator >(decimal x, decimal y);
bool operator <=(decimal x, decimal y);
bool operator >=(decimal x, decimal y);

Elk van deze operatoren vergelijkt de numerieke waarden van de twee decimale operanden en retourneert een bool waarde die aangeeft of de specifieke relatie true of falseis. Elke decimale vergelijking is gelijk aan het gebruik van de overeenkomstige relationele of gelijkheidsoperator van het type System.Decimal.

Opgeheven (§12.4.8) vormen van de niet-opgeheven vooraf gedefinieerde decimale vergelijkingsoperatoren die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.14.5 Booleaanse gelijkheidsoperators

De vooraf gedefinieerde Booleaanse gelijkheidsoperators zijn:

bool operator ==(bool x, bool y);
bool operator !=(bool x, bool y);

Het resultaat van == is true als zowel x als ytrue zijn of als zowel x als yfalsezijn. Anders wordt het resultaat false.

Het resultaat van != is false als zowel x als ytrue zijn of als zowel x als yfalsezijn. Anders wordt het resultaat true. Wanneer de operanden van het type boolzijn, produceert de operator != hetzelfde resultaat als de operator ^.

Opgeheven (§12.4.8) vormen van de niet-gelifte vooraf gedefinieerde booleaanse gelijkheidsoperators die hierboven zijn gedefinieerd, zijn eveneens vooraf gedefinieerd.

12.14.6 Vergelijkingsoperatoren voor opsomming

Elk opsommingstype biedt impliciet de volgende vooraf gedefinieerde vergelijkingsoperatoren

bool operator ==(E x, E y);
bool operator !=(E x, E y);

bool operator <(E x, E y);
bool operator >(E x, E y);
bool operator <=(E x, E y);
bool operator >=(E x, E y);

Het resultaat van het evalueren van x «op» y, waarbij x en y expressies zijn van een opsommingstype E met een onderliggend type U, en «op» een van de vergelijkingsoperatoren is precies hetzelfde als het evalueren van ((U)x) «op» ((U)y). Met andere woorden, de vergelijkingsoperatoren voor opsommingstypen vergelijken de onderliggende integrale waarden van de twee operanden.

Opgeheven (§12.4.8) vormen van de niet-opgeheven vooraf gedefinieerde opsommingsoperators die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.14.7 Verwijzingstype gelijkheidsoperators

Elk klassetype C impliciet de volgende vooraf gedefinieerde referentietype gelijkheidsoperators:

bool operator ==(C x, C y);
bool operator !=(C x, C y);

tenzij vooraf gedefinieerde gelijkheidsoperators anders bestaan voor C (bijvoorbeeld wanneer C is string of System.Delegate).

De operators retourneren het resultaat van het vergelijken van de twee verwijzingen op gelijkheid of ongelijkheid. operator == retourneert true als en alleen als x en y verwijzen naar hetzelfde exemplaar of beide nullzijn, terwijl operator !=true retourneert als en alleen als operator == met dezelfde operanden falsezou retourneren.

Naast de normale toepasbaarheidsregels (§12.6.4.2), vereisen de vooraf gedefinieerde referentietype gelijkheidsoperatoren een van de volgende voorwaarden om van toepassing te zijn:

• Beide operanden zijn een waarde van een type dat bekend staat als een reference_type of de letterlijke null. Bovendien bestaat er een identiteits- of expliciete verwijzingsconversie (§10.3.5) van de ene operand naar het type van de andere operand.
• De ene operand is de letterlijke nullen de andere operand is een waarde van een type T waarbij T een type_parameter is waarvan het niet bekend is of het een waardetype is, en geen waardetypebeperking heeft.
  • Als tijdens runtime T een niet-null-waardetype is, dan zijn de resultaten van == en false respectievelijk != en true.
  • Als tijdens runtime T een null-waardetype is, wordt het resultaat berekend op basis van de HasValue eigenschap van de operand, zoals beschreven in (§12.14.10).
  • Als tijdens runtime T een verwijzingstype is, wordt het resultaat true als de operand is nullen anders false.

Tenzij aan een van deze voorwaarden wordt voldaan, treedt er een bindingstijdfout op.

Opmerking: Belangrijke gevolgen van deze regels zijn:

• Het is een bindingstijdfout om de vooraf gedefinieerde referentietype gelijkheidsoperators te gebruiken om twee verwijzingen te vergelijken die bekend zijn om verschillend te zijn tijdens bindingstijd. Als de bindingstijdtypen van de operanden bijvoorbeeld twee klassetypen zijn en geen van beide zijn afgeleid van de andere, is het onmogelijk voor de twee operanden om naar hetzelfde object te verwijzen. De bewerking wordt dus beschouwd als een bindingstijdfout.
• De vooraf gedefinieerde operatoren voor verwijzingstype gelijkheid staan niet toe dat de operanden van het waardetype worden vergeleken (behalve wanneer typeparameters worden vergeleken met null, die speciaal worden verwerkt).
• Operanden van vooraf gedefinieerde referentietype-gelijkheidsoperators worden nooit geboxed. Het zou zinloos zijn om dergelijke boxing-operaties uit te voeren, aangezien verwijzingen naar de nieuw toegewezen boxed instanties noodzakelijkerwijs afwijken van alle andere verwijzingen.

Voor een bewerking van de vorm x == y of x != y, indien een toepasselijke door de gebruiker gedefinieerde operator == of operator != bestaat, selecteren de regels voor het oplossen van operatoroverbelasting (§12.4.5) die operator in plaats van de vooraf gedefinieerde operator voor gelijkheid van referentietypen. Het is altijd mogelijk om de voorgeconfigureerde gelijkheidsoperator voor referentietypen te selecteren door expliciet een of beide operanden naar type objectte casten.

eindnotitie

Voorbeeld: In het volgende voorbeeld wordt gecontroleerd of een argument van een onbeperkt typeparameter nullis.

class C<T>
{
   void F(T x)
   {
      if (x == null)
      {
          throw new ArgumentNullException();
      }
      ...
   }
}

De x == null constructie is toegestaan, ook al kan T een niet-null-waardetype vertegenwoordigen en wordt het resultaat eenvoudig gedefinieerd om te worden false wanneer T een niet-null-waardetype is.

einde voorbeeld

Voor een bewerking van de vorm x == y of x != y, als er een toepasselijke operator == of operator != bestaat, selecteert de operator-overbelastingsresolutie (§12.4.5) die operator in plaats van de vooraf gedefinieerde operator voor gelijkheid van referentietypen.

Opmerking: Het is altijd mogelijk om de vooraf gedefinieerde operator voor gelijkheid van verwijzingstypen te selecteren door beide operanden expliciet naar type objectte casten. eindnotitie

voorbeeld: het voorbeeld

class Test
{
    static void Main()
    {
        string s = "Test";
        string t = string.Copy(s);
        Console.WriteLine(s == t);
        Console.WriteLine((object)s == t);
        Console.WriteLine(s == (object)t);
        Console.WriteLine((object)s == (object)t);
    }
}

produceert de uitvoer

True
False
False
False

De variabelen s en t verwijzen naar twee afzonderlijke tekenreeksexemplaren met dezelfde tekens. De eerste vergelijkingsuitvoer omdat de vooraf gedefinieerde operator voor gelijkheid van tekenreeksen True (§12.14.8) is geselecteerd wanneer beide operanden van het type stringzijn. De resterende vergelijkingen geven allemaal False als uitvoer omdat de overbelasting van operator == in het string-type niet van toepassing is wanneer een van beide operanden een bindingstijdtype van objectheeft.

Houd er rekening mee dat de bovenstaande techniek niet zinvol is voor waardetypen. Het voorbeeld

class Test
{
    static void Main()
    {
        int i = 123;
        int j = 123;
        Console.WriteLine((object)i == (object)j);
    }
}

geeft False omdat de casts verwijzingen maken naar twee afzonderlijke exemplaren van geboxte int waarden.

einde voorbeeld

12.14.8 Operatoren voor gelijkheid van tekenreeksen

De vooraf gedefinieerde operatoren voor gelijkheid van tekenreeksen zijn:

bool operator ==(string x, string y);
bool operator !=(string x, string y);

Twee string waarden worden als gelijk beschouwd wanneer een van de volgende waarden waar is:

• Beide waarden zijn null.
• Beide waarden zijn niet-null verwijzingen naar tekenreeksexemplaren met identieke lengten en identieke tekens in elke tekenpositie.

De operatoren voor gelijkheid van tekenreeksen vergelijken tekenreekswaarden in plaats van tekenreeksverwijzingen. Wanneer twee afzonderlijke tekenreeksexemplaren exact dezelfde reeks tekens bevatten, zijn de waarden van de tekenreeksen gelijk, maar de verwijzingen verschillen.

Opmerking: Zoals beschreven in §12.14.7, kunnen de operatoren voor gelijkheid van referentietypen worden gebruikt om tekenreeksverwijzingen te vergelijken in plaats van tekenreekswaarden. eindnotitie

12.14.9 Gelijkheidsoperators delegeren

De vooraf gedefinieerde operatoren voor gelijkheid van gemachtigden zijn:

bool operator ==(System.Delegate x, System.Delegate y);
bool operator !=(System.Delegate x, System.Delegate y);

Twee gedelegeerde instanties worden als gelijk beschouwd:

• Als een van de gedelegeerde instanties nullis, zijn ze gelijk als en alleen als beide nullzijn.
• Als de delegaten verschillende runtime-typen hebben, zijn ze nooit gelijk.
• Als beide gemachtigde instanties een aanroeplijst hebben (§21.2), zijn deze instanties gelijk als en alleen als hun aanroeplijsten dezelfde lengte hebben en elke vermelding in de aanroeplijst gelijk is (zoals hieronder gedefinieerd) aan de bijbehorende vermelding in de aanroeplijst van de andere.

De volgende regels bepalen de gelijkheid van vermeldingen in de aanroeplijst:

• Als twee vermeldingen in de aanroeplijst beide verwijzen naar dezelfde statische methode, zijn de vermeldingen gelijk.
• Als twee vermeldingen in de aanroeplijst beide verwijzen naar dezelfde niet-statische methode op hetzelfde doelobject (zoals gedefinieerd door de operatoren voor verwijzings gelijkheid), zijn de vermeldingen gelijk.
• Vermeldingen in de aanroeplijst die zijn geproduceerd uit de evaluatie van semantisch identieke anonieme functies (§12.21) met dezelfde (mogelijk lege) set vastgelegde buitenste variabelenexemplaren zijn toegestaan (maar niet vereist) gelijk te zijn.

Als de oplossing voor overbelasting van operatoren wordt omgezet in een operator voor gedelegeerde gelijkheid en de bindingstijdtypen van beide operanden delegeren zijn, zoals beschreven in §21 in plaats System.Delegatevan , en er geen identiteitsconversie is tussen de operandtypen van het bindingstype, treedt er een bindingstijdfout op.

Opmerking: deze regel voorkomt vergelijkingen die nooit rekening kunnen houden met niet-null-waarden omdat ze verwijzingen zijn naar exemplaren van verschillende typen gedelegeerden. eindnotitie

12.14.10 Gelijkheidsoperatoren tussen typen null-waarden en de letterlijke waarde null

Met de operatoren == en != kan één operand een waarde zijn van een type null-waarde en de andere de letterlijke null zijn, zelfs als er geen vooraf gedefinieerde of door de gebruiker gedefinieerde operator (in niet-opgehaalde of opgeheven vorm) bestaat voor de bewerking.

Voor een bewerking van een van de formulieren

x == null    null == x    x != null    null != x

als x een expressie is van een nullbaar waardetype en de operator overbelastingsresolutie (§12.4.5) geen toepasselijke operator kan vinden, wordt het resultaat in plaats daarvan berekend op basis van de eigenschap HasValue van x. Met name worden de eerste twee formulieren omgezet in !x.HasValueen de laatste twee formulieren worden omgezet in x.HasValue.

12.14.11 Tuple-gelijkheidsoperators

De tupel-gelijkheidsoperatoren worden paarsgewijs toegepast op de elementen van de tupel-operanden in lexicale volgorde.

Als elke operand x en y van een operator == of != wordt geclassificeerd als tupel of als een waarde met een tupletype (§8.3.11), is de operator een tuple-gelijkheidsoperator.

Als een operand e als tuple wordt geclassificeerd, zijn de elementen e1...en de resultaten van het evalueren van de elementexpressies van de tuple-expressie. Anders, als e een waarde van een tupeltype is, zullen de elementen t.Item1...t.Itemn zijn, waarbij t het resultaat is van het evalueren van e.

De operanden x en y van een tuple-gelijkheidsoperator moeten dezelfde arity hebben, of er treedt een compilatietijdfout op. Voor elk paar elementen xi en yiis dezelfde gelijkheidsoperator van toepassing en wordt een resultaat van het type bool, dynamic, een type dat een impliciete conversie naar boolheeft, of een type dat de operatoren true en false definieert.

De tuple-gelijkheidsoperator x == y wordt als volgt geëvalueerd:

• De linkeroperand x wordt geëvalueerd.
• De rechteroperand y wordt geëvalueerd.
• Voor elk paar elementen xi en yi in lexicale volgorde:
  • De operator xi == yi wordt geëvalueerd en het resultaat van het type bool wordt op de volgende manier verkregen:
    • Als de vergelijking een bool oplevert, is dat het resultaat.
    • Anders, als de vergelijking een dynamic oplevert, wordt de operator false er dynamisch op aangeroepen en wordt de resulterende bool-waarde met de logische negatieoperator (!) ontkend.
    • Anders wordt die conversie toegepast als het type van de vergelijking een impliciete conversie naar boolheeft.
    • Anders, als het type van de vergelijking een operator falseheeft, dan wordt die operator aangeroepen en wordt de resulterende bool-waarde geïnverteerd met de logische negatieoperator (!).
  • Als de resulterende boolfalseis, wordt er geen verdere evaluatie uitgevoerd en wordt het resultaat van de tuple-gelijkheidsoperator false.
• Als alle elementvergelijkingen trueopleveren, wordt het resultaat van de tupel gelijkheidsoperator true.

De tuple-gelijkheidsoperator x != y wordt als volgt geëvalueerd:

• De linkeroperand x wordt geëvalueerd.
• De rechteroperand y wordt geëvalueerd.
• Voor elk paar elementen xi en yi in lexicale volgorde:
  • De operator xi != yi wordt geëvalueerd en het resultaat van het type bool wordt op de volgende manier verkregen:
    • Als de vergelijking een bool oplevert, is dat het resultaat.
    • Anders, als de vergelijking een dynamic oplevert, wordt de operator true er dynamisch op aangeroepen en is de resulterende waarde bool het resultaat.
    • Anders wordt die conversie toegepast als het type van de vergelijking een impliciete conversie naar boolheeft.
    • Als het type van de vergelijking een operator trueheeft, wordt deze operator aangeroepen en is de resulterende waarde bool het resultaat.
  • Als de resulterende booltrueis, wordt er geen verdere evaluatie uitgevoerd en wordt het resultaat van de tuple-gelijkheidsoperator true.
• Als alle elementvergelijkingen falseopleveren, wordt het resultaat van de tupel gelijkheidsoperator false.

12.14.12 De operator is

Er zijn twee vormen van de operator is. Een hiervan is de is-type operator, die een type aan de rechterzijde heeft. De andere is de is-pattern operator, die een patroon aan de rechterkant heeft.

12.14.12.1 De operator is-type

De is-type operator wordt gebruikt om te controleren of het runtimetype van een object compatibel is met een bepaald type. De controle wordt uitgevoerd tijdens runtime. Het resultaat van de bewerking E is T, waarbij E een expressie is en T een ander type is dan dynamic, is een Booleaanse waarde die aangeeft of E niet-null is en kan worden geconverteerd naar type T door een verwijzingsconversie, een boksconversie, een conversie voor uitpakken, een terugloopconversie of een uitgepakte conversie.

De bewerking E is T wordt als volgt geëvalueerd:

1. Als E een anonieme functie of methodegroep is, treedt er een compilatietijdfout op.
2. Als T een null-referentietype (§8.9.3) is, treedt er een compilatietijdfout op.
3. Als E de letterlijke null is of als de waarde van Enullis, wordt het resultaat false.
4. Anders:
   1. Laat R het runtimetype van Ezijn.
   2. Laten we D als volgt worden afgeleid:R
      1. Als R een null-waardetype is, is D het onderliggende type R.
      2. Anders wordt DR.
   3. Het resultaat is afhankelijk D van en T als volgt:
      1. Als T een verwijzingstype is, wordt het resultaat true als:
         • er een identiteitsconversie bestaat tussen D en T, of
         • D is een verwijzingstype en een impliciete verwijzingsconversie van D tot T bestaat, of
         • D is een waardetype en een boksconversie van D naar T bestaat.
      2. Als T een null-waarde type is, is het resultaat true als D het onderliggende type van Tis.
      3. Als T een niet-null-waardetype is, wordt het resultaat true als D en T hetzelfde type zijn.
      4. Anders wordt het resultaat false.

Door de gebruiker gedefinieerde conversies worden niet meegenomen door de operator is.

Opmerking: als de operator is tijdens runtime wordt geëvalueerd, zijn alle typeargumenten vervangen en zijn er geen open typen (§8.4.3) om rekening mee te houden. eindnotitie

Opmerking: de operator is kan als volgt worden begrepen in termen van compileertijdtypen en conversies, waarbij C het type compilatietijd van Eis:

• Als het compileertijdtype van e hetzelfde is als Tof als een impliciete verwijzingsconversie (§10.2.8), boksconversie (§10.2.9), wrapconversie (§10.6), of een expliciete uitgepakte conversie (§10.6) bestaat vanuit het compileertijdtype van E naar T:
  • Als C van een niet-null-waardetype is, wordt het resultaat van de bewerking true.
  • Anders is het resultaat van de bewerking gelijk aan het evalueren van E != null.
• Als er anders een expliciete verwijzingsconversie (§10.3.5) of het uitpakken van conversie (§10.3.7) bestaat van C of Tals C of T een open type is (§8.4.3), worden runtimecontroles zoals hierboven uitgevoerd.
• Anders is er geen referentie-, boks-, inpak- of uitpakconversie van E naar type T mogelijk, en het resultaat van de bewerking is false. Een compiler kan optimalisaties implementeren op basis van het type compileertijd.

eindnotitie

12.14.12.2 De operator is-patroon

De is-patroonoperator wordt gebruikt om te controleren of de waarde die wordt berekend door een expressie overeenkomt met een bepaald patroon (§11). De controle wordt uitgevoerd tijdens runtime. Het resultaat van de is-patroon operator is waar als de waarde overeenkomt met het patroon, anders is het onwaar.

Voor een expressie van het formulier E is P, waarbij E een relationele expressie van het type T is en P een patroon is, is het een compilatiefout als een van de volgende bewaringen geldt:

• E wijst geen waarde aan of heeft geen type.
• Het patroon P is niet van toepassing (§11.2) op het type T.

Elke single_variable_designation van het patroon introduceert een nieuwe lokale variabele die zeker is toegewezen (§9.4) wanneer de bijbehorende relational_expression test true.

12.14.13 De operator

De operator as wordt gebruikt om expliciet een waarde te converteren naar een bepaald verwijzingstype of null-waardetype. In tegenstelling tot een cast-expressie (§12.9.8) genereert de as operator nooit een uitzondering. Als de aangegeven conversie niet mogelijk is, wordt de resulterende waarde null.

In een operatie van de vorm E as Tmoet E een expressie zijn en T een verwijzingstype zijn, een typeparameter die bekend staat als een verwijzingstype, of een null-waarde type. Bovendien is ten minste één van de volgende waar, of op andere wijze treedt er een compilatietijdfout op:

• Een identiteitsconversie (§10.2.2), impliciete nullable-conversie (§10.2.6), impliciete verwijzingsconversie (§10.2.8), boxing-conversie (§10.2.9), expliciete nullable-conversie (§10.3.4), expliciete verwijzingsconversie (§10.3.5), of wrapping-conversie (§8.3.12) bestaat van E tot T.
• Het type E of T is een open type.
• E is de letterlijke waarde van null.

Als het type compilatietijd van E niet is dynamic, produceert de bewerking E as T hetzelfde resultaat als

E is T ? (T)(E) : (T)null

behalve dat E slechts eenmaal wordt geëvalueerd. Er kan worden verwacht dat een compiler E as T optimaliseert om maximaal één runtimetypecontrole uit te voeren in plaats van de twee runtimetypecontroles die worden geïmpliceerd door de bovenstaande uitbreiding.

Als het compilatietijdtype van Edynamicis, dan is, in tegenstelling tot de cast-operator, de operator as niet dynamisch gebonden (§12.3.3). Daarom is de uitbreiding in dit geval:

E is T ? (T)(object)(E) : (T)null

Houd er rekening mee dat sommige conversies, zoals door de gebruiker gedefinieerde conversies, niet mogelijk zijn met de operator as en in plaats daarvan moeten worden uitgevoerd met cast-expressies.

Voorbeeld: In het voorbeeld

class X
{
    public string F(object o)
    {
        return o as string;  // OK, string is a reference type
    }

    public T G<T>(object o)
        where T : Attribute
    {
        return o as T;       // Ok, T has a class constraint
    }

    public U H<U>(object o)
    {
        return o as U;       // Error, U is unconstrained
    }
}

de typeparameter T van G is een referentietype, omdat het de klassebeperking heeft. Het typeparameter U van H is echter niet; vandaar dat het gebruik van de operator as in H niet is toegestaan.

einde voorbeeld

12.15 Logische operators

12.15.1 Algemeen

De operators &, ^en | worden de logische operatoren genoemd.

and_expression
    : equality_expression
    | and_expression '&' equality_expression
    ;

exclusive_or_expression
    : and_expression
    | exclusive_or_expression '^' and_expression
    ;

inclusive_or_expression
    : exclusive_or_expression
    | inclusive_or_expression '|' exclusive_or_expression
    ;

Als een operand van een logische operator het type compileertijd heeft dynamic, is de expressie dynamisch gebonden (§12.3.3). In dit geval is het compile-tijdtype van de expressie dynamic, en zal de hieronder beschreven resolutie plaatsvinden tijdens de uitvoertijd met behulp van het uitvoertijdtype van die operanden die het compile-tijdtype dynamichebben.

Voor een werking van het formulier x «op» y, waarbij «op» een van de logische operatoren is, wordt overbelastingsresolutie (§12.4.5) toegepast om een specifieke operator-implementatie te selecteren. De operanden worden geconverteerd naar de parametertypen van de geselecteerde operator en het type van het resultaat is het retourtype van de operator.

De vooraf gedefinieerde logische operators worden beschreven in de volgende subclauses.

12.15.2 Logische operatoren voor gehele getallen

De vooraf gedefinieerde logische operatoren voor gehele getallen zijn:

int operator &(int x, int y);
uint operator &(uint x, uint y);
long operator &(long x, long y);
ulong operator &(ulong x, ulong y);

int operator |(int x, int y);
uint operator |(uint x, uint y);
long operator |(long x, long y);
ulong operator |(ulong x, ulong y);

int operator ^(int x, int y);
uint operator ^(uint x, uint y);
long operator ^(long x, long y);
ulong operator ^(ulong x, ulong y);

De operator & berekent de bitsgewijze logische EN van de twee operanden, de operator | berekent de bitsgewijze logische OR van de twee operanden, en de operator ^ berekent de bitsgewijze logische exclusieve OR van de twee operanden. Er zijn geen overloopmogelijkheden bij deze bewerkingen.

Opgeheven (§12.4.8) vormen van de niet-opgeheven, vooraf gedefinieerde logische operatoren voor gehele getallen die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

Logische operatoren 12.15.3 Opsomming

Elk opsommingstype E impliciet de volgende vooraf gedefinieerde logische operators biedt:

E operator &(E x, E y);
E operator |(E x, E y);
E operator ^(E x, E y);

Het resultaat van het evalueren van x «op» y, waarbij x en y expressies zijn van een opsommingstype E met een onderliggend type Uen «op» een van de logische operatoren is, is precies hetzelfde als het evalueren van (E)((U)x «op» (U)y). Met andere woorden, de logische operatoren van het opsommingstype voeren de logische bewerking uit op het onderliggende type van de twee operanden.

Opgeheven (§12.4.8) vormen van de niet-opgeheven, vooraf gedefinieerde logische enumeratieoperators die hierboven zijn gedefinieerd, zijn ook vooraf gedefinieerd.

12.15.4 Booleaanse logische operators

De vooraf gedefinieerde logische booleaanse operators zijn:

bool operator &(bool x, bool y);
bool operator |(bool x, bool y);
bool operator ^(bool x, bool y);

Het resultaat van x & y is true als zowel x als ytruezijn. Anders wordt het resultaat false.

Het resultaat van x | y is true als x of ytrueis. Anders wordt het resultaat false.

Het resultaat van x ^ y is true als xtrue is en yfalseis, of xfalse is en y is true. Anders wordt het resultaat false. Wanneer de operanden van het type boolzijn, berekent de operator ^ hetzelfde resultaat als de operator !=.

12.15.5 Nullable Boolean & and | Exploitanten

Het nulbare booleaanse type bool? kan drie waarden, true, falseen null, vertegenwoordigen.

Net als bij de andere binaire operatoren zijn opgeheven vormen van de logische operatoren & en | (§12.15.4) ook vooraf gedefinieerd:

bool? operator &(bool? x, bool? y);
bool? operator |(bool? x, bool? y);

De semantiek van de opgeheven & en | operatoren worden gedefinieerd door de volgende tabel: