Over deze regel code gelopen:
FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();
Wat betekenen de twee vraagtekens, is het een soort ternaire operator?
Het is moeilijk om op te zoeken in Google.
Antwoord 1, autoriteit 100%
Het is de null-coalescentie-operator en lijkt veel op de ternaire (onmiddellijke als)-operator. Zie ook ?? Operator – MSDN.
FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();
uitbreidt tot:
FormsAuth = formsAuth != null ? formsAuth : new FormsAuthenticationWrapper();
die verder wordt uitgebreid tot:
if(formsAuth != null)
FormsAuth = formsAuth;
else
FormsAuth = new FormsAuthenticationWrapper();
In het Engels betekent het: “Als wat links staat niet nul is, gebruik dat dan, gebruik anders wat rechts staat.”
Houd er rekening mee dat u een willekeurig aantal van deze achtereenvolgens kunt gebruiken. De volgende instructie wijst het eerste niet-null Answer#toe aan Answer(als alle antwoorden nul zijn, is het Answernull):
string Answer = Answer1 ?? Answer2 ?? Answer3 ?? Answer4;
Het is ook het vermelden waard, hoewel de bovenstaande uitbreiding conceptueel equivalent is, wordt het resultaat van elke expressie slechts één keer geëvalueerd. Dit is belangrijk als een expressie bijvoorbeeld een methodeaanroep is met neveneffecten. (Met dank aan @Joey voor het erop wijzen.)
Antwoord 2, autoriteit 13%
Gewoon omdat nog niemand de magische woorden heeft gezegd: het is de nulcoalescentie-operator. Het wordt gedefinieerd in sectie 7.12 van de C# 3.0 taalspecificatie.
Het is erg handig, vooral vanwege de manier waarop het werkt wanneer het meerdere keren in een expressie wordt gebruikt. Een uitdrukking van de vorm:
a ?? b ?? c ?? d
geeft het resultaat van uitdrukking aals het niet-null is, probeer anders b, probeer anders c, probeer anders d. Het maakt op elk punt kortsluiting.
Als het type dniet-nullable is, is het type van de hele expressie ook niet-nullable.
Antwoord 3, autoriteit 3%
Het is de null-coalescentie-operator.
http://msdn.microsoft.com/en-us/library/ ms173224.aspx
Ja, bijna onmogelijk om naar te zoeken, tenzij je weet hoe het heet! 🙂
EDIT: En dit is een leuke functie van een andere vraag. Je kunt ze aan elkaar koppelen.
Antwoord 4
Bedankt iedereen, hier is de meest beknopte uitleg die ik op de MSDN-site heb gevonden:
// y = x, unless x is null, in which case y = -1.
int y = x ?? -1;
Antwoord 5
De twee vraagtekens (??) geven aan dat het een Coalescing-operator is.
Coalescerende operator retourneert de eerste NON-NULL-waarde van een keten. Je kunt deze YouTube-videozien die het geheel praktisch laat zien.
Maar laat me nog meer toevoegen aan wat de video zegt.
Als je de Engelse betekenis van samenvoegen ziet, staat er ‘samen consolideren’. Hieronder staat bijvoorbeeld een eenvoudige code die vier strings aaneenrijgt.
Dus als str1nullis, zal het str2proberen, als str2nullhet zal str3proberen, enzovoort totdat het een tekenreeks vindt met een niet-null-waarde.
string final = str1 ?? str2 ?? str3 ?? str4;
In eenvoudige woorden Coalescing-operator retourneert de eerste NON-NULL-waarde van een keten.
Antwoord 6
??is er om een waarde op te geven voor een null-type wanneer de waarde null is. Dus als formAuth null is, zal het nieuwe FormsAuthenticationWrapper() retourneren.
Antwoord 7
Het is een korte hand voor de ternaire operator.
FormsAuth = (formsAuth != null) ? formsAuth : new FormsAuthenticationWrapper();
Of voor degenen die geen ternair doen:
if (formsAuth != null)
{
FormsAuth = formsAuth;
}
else
{
FormsAuth = new FormsAuthenticationWrapper();
}
Antwoord 8
Als je bekend bent met Ruby, de ||=lijkt me verwant aan de ??van C#. Hier is wat Ruby:
irb(main):001:0> str1 = nil
=> nil
irb(main):002:0> str1 ||= "new value"
=> "new value"
irb(main):003:0> str2 = "old value"
=> "old value"
irb(main):004:0> str2 ||= "another new value"
=> "old value"
irb(main):005:0> str1
=> "new value"
irb(main):006:0> str2
=> "old value"
En in C#:
string str1 = null;
str1 = str1 ?? "new value";
string str2 = "old value";
str2 = str2 ?? "another new value";
Antwoord 9
coalescentie-operator
het is gelijk aan
FormsAuth = formsAUth == null ? new FormsAuthenticationWrapper() : formsAuth
Antwoord 10
Hier is niets gevaarlijks aan. Sterker nog, het is prachtig.
U kunt een standaardwaarde toevoegen als dat wenselijk is, bijvoorbeeld:
CODE
int x = x1 ?? x2 ?? x3 ?? x4 ?? 0;
Antwoord 11
Zoals terecht opgemerkt in talloze antwoorden, is dat de “nul-coalescentie-operator” (??), waarover je misschien ook zijn neef de “Null-voorwaardelijke operator” (?.of ?[) dat is een operator die vaak wordt gebruikt in combinatie met ??
Wordt gebruikt om te testen op null voordat een ledentoegang (?.) of index (?[) bewerking wordt uitgevoerd. Deze operators helpen je om minder code te schrijven om null-controles af te handelen, vooral voor het afdalen in datastructuren.
Bijvoorbeeld:
// if 'customers' or 'Order' property or 'Price' property is null,
// dollarAmount will be 0
// otherwise dollarAmount will be equal to 'customers.Order.Price'
int dollarAmount = customers?.Order?.Price ?? 0;
de oude manier zonder ?.en ??om dit te doen is
int dollarAmount = customers != null
&& customers.Order!=null
&& customers.Order.Price!=null
? customers.Order.Price : 0;
wat uitgebreider en omslachtiger is.
Antwoord 12
Alleen voor uw vermaak (wetende dat u allemaal C#-jongens bent ;-).
Ik denk dat het is ontstaan in Smalltalk, waar het al vele jaren bestaat. Het wordt daar gedefinieerd als:
in object:
? anArgument
^ self
in UndefinedObject (ook bekend als de klasse van nul):
? anArgument
^ anArgument
Er zijn zowel evaluerende (?) als niet-evaluerende versies (??) hiervan.
Het wordt vaak gevonden in getter-methoden voor luie geïnitialiseerde privé (instantie) variabelen, die nul blijven totdat ze echt nodig zijn.
Antwoord 13
Opmerking:
Ik heb deze thread en vele andere gelezen, maar ik kan niet zo’n grondig antwoord vinden als dit.
Waardoor ik het “waarom ?? gebruiken en wanneer ?? en hoe ?? gebruiken” volledig begreep.
Bron:
Windows-communicatiebasis ontketend door Craig McMurtry
ISBN 0-672-32948-4
Nullable-waardetypen
Er zijn twee veelvoorkomende omstandigheden waarin men zou willen weten of:
een waarde is toegewezen aan een instantie van een waardetype. De eerste is wanneer de instantie een waarde in een database vertegenwoordigt. In zo’n geval zou men de instantie willen kunnen onderzoeken om na te gaan of er inderdaad een waarde in de database aanwezig is. De andere omstandigheid, die meer relevant is voor het onderwerp van dit boek, is wanneer de instantie een gegevensitem vertegenwoordigt dat is ontvangen van een externe bron. Nogmaals, men zou uit de instantie willen bepalen of een waarde voor dat gegevensitem is ontvangen.
Het .NET Framework 2.0 bevat een generieke typedefinitie die voorziet in gevallen als deze waarin men null wil toewijzen aan een instantie van een waardetype, en testen of de waarde van de instantie null is. Die generieke typedefinitie is System.Nullable<T>, die de generieke typeargumenten die T kunnen vervangen, beperkt tot waardetypen.
Aan instanties van typen die zijn samengesteld uit System.Nullable<T>kan de waarde null; inderdaad, hun waarden zijn standaard null. Dus typen opgebouwd uit
System.Nullable<T>kan worden aangeduid als nullable-waardetypes.
System.Nullable<T>heeft een eigenschap, Value, waarmee de waarde die is toegewezen aan een instantie van
een daaruit geconstrueerd type kan worden verkregen als de waarde van de instantie niet null is.
Daarom kan men schrijven:
System.Nullable<int> myNullableInteger = null;
myNullableInteger = 1;
if (myNullableInteger != null)
{
Console.WriteLine(myNullableInteger.Value);
}
De programmeertaal C# biedt een verkorte syntaxis voor het declareren van typen
opgebouwd uit System.Nullable<T>. Met die syntaxis kan men afkorten:
System.Nullable<int> myNullableInteger;
naar
int? myNullableInteger;
De compiler zal voorkomen dat iemand op deze manier probeert de waarde van een nullable waardetype toe te wijzen aan een gewoon waardetype:
int? myNullableInteger = null;
int myInteger = myNullableInteger;
Het voorkomt dat iemand dit doet omdat het waardetype met nullwaarde de waarde null zou kunnen hebben, wat het in dit geval ook zou hebben, en die waarde kan niet worden toegewezen aan een gewoon waardetype. Hoewel de compiler deze code zou toestaan,
int? myNullableInteger = null;
int myInteger = myNullableInteger.Value;
De tweede instructie zou ervoor zorgen dat er een uitzondering wordt gegenereerd omdat elke poging om
toegang tot de eigenschap System.Nullable<T>.Value is een ongeldige bewerking als het type
opgebouwd uit System.Nullable<T>heeft geen geldige waarde T gekregen, wat in dit geval niet is gebeurd.
Conclusie:
Een juiste manier om de waarde van een nullable-waardetype toe te wijzen aan een gewoon waardetype is door de eigenschap System.Nullable<T>.HasValue te gebruiken om vast te stellen of een geldige waarde van T is toegewezen aan het waardetype nullable:
int? myNullableInteger = null;
if (myNullableInteger.HasValue)
{
int myInteger = myNullableInteger.Value;
}
Een andere optie is om deze syntaxis te gebruiken:
int? myNullableInteger = null;
int myInteger = myNullableInteger ?? -1;
Waarmee aan het gewone gehele getal myInteger de waarde van het nullable integer “myNullableInteger” wordt toegekend als aan dit laatste een geldige integer waarde is toegekend; anders krijgt myInteger de waarde -1.
Antwoord 14
Sommige voorbeelden hier van het verkrijgen van waarden met behulp van coalescentie zijn inefficiënt.
Wat je echt wilt is:
return _formsAuthWrapper = _formsAuthWrapper ?? new FormsAuthenticationWrapper();
of
return _formsAuthWrapper ?? (_formsAuthWrapper = new FormsAuthenticationWrapper());
Dit voorkomt dat het object elke keer opnieuw wordt gemaakt. In plaats van dat de privévariabele null blijft en er bij elk verzoek een nieuw object wordt gemaakt, zorgt dit ervoor dat de privévariabele wordt toegewezen als het nieuwe object wordt gemaakt.
Antwoord 15
Anderen hebben de Null Coalescing Operatorvrij goed beschreven. In gevallen waar een enkele test voor null vereist is, kan de verkorte syntaxis ??=de leesbaarheid vergroten.
Verouderde null-test:
if (myvariable == null)
{
myvariable = new MyConstructor();
}
Met de Null Coalescing Operator kan dit worden geschreven:
myvariable = myvariable ?? new MyConstructor();
die ook kan worden geschreven met de verkorte syntaxis:
myvariable ??= new MyConstructor();
Sommigen vinden het leesbaarder en beknopter.
Antwoord 16
Het is een null-coalescentie-operator die op dezelfde manier werkt als een ternaire operator.
a ?? b => a !=null ? a : b
Een ander interessant punt hiervoor is:
“Een null-type kan een waarde bevatten, of het kan ongedefinieerd zijn”.
Dus als u probeert een nullable waardetype toe te wijzen aan een niet-nullable waardetype
je krijgt een compile-time error.
int? x = null; // x is nullable value type
int z = 0; // z is non-nullable value type
z = x; // compile error will be there.
Dus om dat te doen met ?? operator:
z = x ?? 1; // with ?? operator there are no issues
Antwoord 17
FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();
is gelijk aan
FormsAuth = formsAuth != null ? formsAuth : new FormsAuthenticationWrapper();
Maar het leuke is dat je ze kunt vastketenen, zoals andere mensen zeiden.
Het enige waar niet op is ingegaan, is dat je het echt kunt gebruiken om een uitzondering te maken.
A = A ?? B ?? throw new Exception("A and B are both NULL");
Antwoord 18
De operator ??wordt de null-coalescing-operator genoemd. Het geeft de linker operand terug als de operand niet nul is; anders retourneert het de rechterhand operand.
int? variable1 = null;
int variable2 = variable1 ?? 100;
Stel variable2in op de waarde van variable1, als variable1NIET null is;
anders, als variable1 == null, stel variable2in op 100.
Antwoord 19
Op de eenvoudigste manier worden twee vraagtekens ‘Coalescing Operator’ genoemd, die de eerste niet-nulwaarde van de keten retourneert.
bijv. als u waarden krijgt van een object met nulling, in een variabele die niet nullbaar is, dan kunt u deze operator gebruiken.
d.w.z.
int a = 1;
int? b = nul;
a = b??0;
Het resultaat van bovenstaande vergelijking zou nul zijn, omdat b nul is en we de ?? hebben gebruikt. operator samen met nul, wat betekent dat het 0 zal retourneren als en alleen als b null is.
int a = 1;
int? b = 15;
a = b??0;
In bovenstaande vergelijking krijgt a de waarde “15” omdat b een geldige waarde heeft en niet null is.
Ook kunt u niet gebruiken ?? operator op een niet-nulbaar object.
In bovenstaande voorbeelden heb ik ?? 0, maar een compleet nieuwe vergelijking kan ook worden gebruikt na ?? operator.
Zoals
a = b?? ( x==1 ? 10 : 15)
Ik hoop dat het je vraag duidelijk zal maken.