මෙම කේත රේඛාව හරහා දිව යන්න:

FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();

ප්‍රශ්න ලකුණු දෙකෙන් අදහස් කරන්නේ කුමක්ද, එය යම් ආකාරයක ත්‍රික ක්‍රියාකරුවෙකුද? ගූගල් හි සොයා බැලීම දුෂ්කර ය.

එය ශුන්‍ය සිසිලන ක්‍රියාකරු වන අතර එය ත්‍රික (ක්ෂණික නම්) ක්‍රියාකරුට සමානය. මෙයද බලන්න ?? ක්රියාකරු - MSDN .

FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();

දක්වා පුළුල් වේ:

FormsAuth = formsAuth != null ? formsAuth : new FormsAuthenticationWrapper();

එය තවදුරටත් පුළුල් වන්නේ:

if(formsAuth != null)
    FormsAuth = formsAuth;
else
    FormsAuth = new FormsAuthenticationWrapper();

ඉංග්‍රීසියෙන් එහි තේරුම "වමට ඇති සියල්ල ශුන්‍ය නොවේ නම්, එය භාවිතා කරන්න, එසේ නොමැතිනම් දකුණට ඇති දේ භාවිතා කරන්න."

ඔබට මේවායින් ඕනෑම සංඛ්‍යාවක් අනුපිළිවෙලින් භාවිතා කළ හැකි බව සලකන්න. පහත දැක්වෙන ප්රකාශය පළමු නොවන ශූන්ය පවරනු ඇත Answer#කිරීමට Answer(සියළුම පිළිතුරු ශූන්ය වේ නම්, එවිට එම Answerශූන්ය වේ):

string Answer = Answer1 ?? Answer2 ?? Answer3 ?? Answer4;

ඉහත ප්‍රසාරණය සංකල්පමය වශයෙන් සමාන වන අතර, එක් එක් ප්‍රකාශනයේ ප්‍රති result ලය තක්සේරු කරනු ලබන්නේ එක් වරක් පමණි. නිදසුනක් ලෙස ප්‍රකාශනයක් යනු අතුරු ආබාධ සහිත ක්‍රම ඇමතුමක් නම් මෙය වැදගත් වේ. (මෙය පෙන්වා දීම සඳහා @ ජෝයිට ණය.)

වෙනත් කිසිවෙකු තවමත් මැජික් වචන පවසා නැති නිසා: එය ශුන්‍ය සිසිලන ක්‍රියාකරු ය . එය C # 3.0 භාෂා පිරිවිතරයේ 7.12 වගන්තියේ අර්ථ දක්වා ඇත .

එය ඉතා පහසුය, විශේෂයෙන් එය ප්‍රකාශනයක කිහිප වතාවක් භාවිතා කරන විට එය ක්‍රියා කරන ආකාරය නිසාය. පෝරමයේ ප්‍රකාශනයක්:

a ?? b ?? c ?? d

ප්‍රකාශනයේ aප්‍රති result ලය එය ශුන්‍ය නොවේ නම් ලබා දෙනු ඇත, එසේ නොමැතිනම් උත්සාහ කරන්න b, එසේ නොමැතිනම් උත්සාහ කරන්න c, නැතිනම් උත්සාහ කරන්න d. එය සෑම අවස්ථාවකම කෙටි පරිපථ.

එසේම, වර්ගය dඅහෝසි කළ නොහැකි නම්, සමස්ත ප්‍රකාශනයේ වර්ගය ද අහෝසි කළ නොහැකි ය.

එය ශුන්‍ය සිසිලන ක්‍රියාකරු ය.

http://msdn.microsoft.com/en-us/library/ms173224.aspx

ඔව්, එය හැඳින්වූයේ කුමක්දැයි ඔබ නොදන්නේ නම් සෙවීමට නොහැකි තරම්ය! :-)

සංස්කරණය කරන්න: මෙය වෙනත් ප්‍රශ්නයකින් ලැබෙන සිසිල් ලක්ෂණයකි. ඔබට ඒවා දම්වැල් කළ හැකිය.

සී # හි සැඟවුණු විශේෂාංග?

සැමට ස්තූතියි, එම්එස්ඩීඑන් වෙබ් අඩවියෙන් මා සොයාගත් වඩාත් සංක්ෂිප්ත පැහැදිලි කිරීම මෙන්න:

// y = x, unless x is null, in which case y = -1.
int y = x ?? -1;

??අගය ශුන්‍ය වන විට අහෝසි කළ හැකි වර්ගයක් සඳහා අගයක් සැපයීමට තිබේ. එබැවින්, FormAuth ශුන්‍ය නම්, එය නව FormsAuthenticationWrapper () නැවත ලබා දෙනු ඇත.

ප්‍රශ්න ලකුණු දෙකෙන් (??) පෙන්නුම් කරන්නේ එහි සමතුලිත ක්‍රියාකරු බවයි.

සංගුණක ක්‍රියාකරු දාමයකින් පළමු NON-NULL අගය ලබා දෙයි. සමස්තයක්ම ප්‍රායෝගිකව නිරූපණය කරන මෙම යූ ටියුබ් වීඩියෝව ඔබට දැක ගත හැකිය .

නමුත් වීඩියෝව පවසන දෙයට තවත් එකතු කිරීමට මට ඉඩ දෙන්න.

ඒකාබද්ධ වීමේ ඉංග්‍රීසි තේරුම ඔබ දුටුවහොත් එය පවසන්නේ “එකට ඒකාබද්ධ වන්න” යන්නයි. උදාහරණයක් ලෙස පහත දැක්වෙන්නේ නූල් හතරක් දම්වැලකින් යුත් සරල සිසිලන කේතයකි.

එසේ නම් str1වේ nullඑය උත්සාහ කරනු ඇත str2නම්, str2වේ nullඑය උත්සාහ කරනු ඇත str3සහ ඒ නිසා එය-ශූන්ය නොවන වටිනාකමක් සහිත වැලක් සම්බ වන තුරු මත.

string final = str1 ?? str2 ?? str3 ?? str4;

සරල වචන වලින් කිවහොත්, දඟර ක්‍රියාකරු පළමු NON-NULL අගය දාමයකින් ලබා දෙයි.

එය ත්‍රිමාණ ක්‍රියාකරුට කෙටි අතකි.

FormsAuth = (formsAuth != null) ? formsAuth : new FormsAuthenticationWrapper();

හෝ ත්‍රිකෝණය නොකරන අයට:

if (formsAuth != null)
{
  FormsAuth = formsAuth;
}
else
{
  FormsAuth = new FormsAuthenticationWrapper();
}

ඔබ රූබි සමඟ හුරුපුරුදු නම්, එය මට ||=C # ට සමාන බව පෙනේ ??. මෙන්න රූබි කිහිපයක්:

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"

සහ සී # හි:

string str1 = null;
str1 = str1 ?? "new value";
string str2 = "old value";
str2 = str2 ?? "another new value";

සමතුලිත ක්‍රියාකරු

එය සමාන වේ

FormsAuth = formsAUth == null ? new FormsAuthenticationWrapper() : formsAuth

මේ ගැන භයානක කිසිවක් නැත. ඇත්ත වශයෙන්ම, එය ලස්සනයි. එය සුදුසු නම් ඔබට පෙරනිමි අගය එකතු කළ හැකිය, උදාහරණයක් ලෙස:

කේතය

int x = x1 ?? x2 ?? x3 ?? x4 ?? 0;

බොහෝ පිළිතුරු වලින් නිවැරදිව පෙන්වා ඇති පරිදි, “ශුන්‍ය සිසිලන ක්‍රියාකරු” ( ?? ), ඒ ගැන කතා කිරීමෙන් ඔබට එහි ous ාති සහෝදරයා වන “ශුන්‍ය-කොන්දේසි සහිත ක්‍රියාකරු” ( ? හෝ ? [ ) පරීක්ෂා කර බැලීමට අවශ්‍ය වනු ඇත . බොහෝ විට එය සමඟ ඒකාබද්ධව භාවිතා වේ ??

ශුන්‍ය-කොන්දේසි සහිත ක්‍රියාකරු

සාමාජික ප්‍රවේශයක් ( ?. ) හෝ දර්ශක ( ? [ ) මෙහෙයුමක් කිරීමට පෙර ශුන්‍යය සඳහා පරීක්ෂා කිරීමට භාවිතා කරයි . ශුන්‍ය චෙක්පත් හැසිරවීමට අඩු කේතයක් ලිවීමට මෙම ක්‍රියාකරුවන් ඔබට උදව් කරයි, විශේෂයෙන් දත්ත ව්‍යුහයන්ට බැසීමට.

උදාහරණයක් වශයෙන්:

// 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; 

නැතිව පැරණි ක්‍රමය ?. සහ ?? මෙය කිරීම

int dollarAmount = customers != null 
                   && customers.Order!=null
                   && customers.Order.Price!=null 
                    ? customers.Order.Price : 0; 

එය වඩාත් වාචික හා කරදරකාරී ය.

ඔබගේ විනෝදය සඳහා පමණි (ඔබ සියල්ලන්ම C # යාලුවනේ බව දැන ගැනීම ;-).

මම හිතන්නේ එය ආරම්භ වූයේ ස්මාල්ටෝක්හි, එය වසර ගණනාවක් තිස්සේ පැවතුනි. එය එහි අර්ථ දැක්වෙන්නේ:

වස්තුව තුළ:

? anArgument
    ^ self

නිර්වචනය නොකළ වස්තුවෙහි (නිල් පන්තියේ):

? anArgument
    ^ anArgument

මෙහි ඇගයීම් (?) සහ ඇගයීමට ලක් නොකරන අනුවාද (??) යන දෙකම ඇත.
එය බොහෝ විට කම්මැලි-ආරම්භක පුද්ගලික (නිදර්ශන) විචල්‍යයන් සඳහා වන ක්‍රමවේදයන් තුළ දක්නට ලැබේ, ඒවා සැබවින්ම අවශ්‍ය වන තෙක් ඉතිරි නොවේ.

සමතුලිතතාවය භාවිතා කරමින් අගයන් ලබා ගැනීම සඳහා මෙහි උදාහරණ සමහරක් අකාර්යක්ෂම වේ.

ඔබට සැබවින්ම අවශ්‍ය වන්නේ:

return _formsAuthWrapper = _formsAuthWrapper ?? new FormsAuthenticationWrapper();

හෝ

return _formsAuthWrapper ?? (_formsAuthWrapper = new FormsAuthenticationWrapper());

මෙමඟින් වස්තුව සෑම විටම ප්‍රතිනිර්මාණය වීම වළක්වයි. පුද්ගලික ඉල්ලුමේ ඉතිරිව ඇති ශුන්‍යය සහ සෑම ඉල්ලීමකටම නව වස්තුවක් නිර්මාණය කිරීම වෙනුවට, නව වස්තුව නිර්මාණය කළ හොත් පුද්ගලික විචල්‍යය පැවරීම සහතික කරයි.

සටහන:

මම මේ ත්‍රෙඩ් එක සහ තවත් බොහෝ දේ කියවා ඇති නමුත් මට මේ තරම් ගැඹුරු පිළිතුරක් සොයාගත නොහැක.

"භාවිතා කරන්නේ ඇයි ?? සහ කවදා භාවිතා කළ යුතුද ?? සහ භාවිතා කරන්නේ කෙසේද ??"

මූලාශ්රය:

වින්ඩෝස් සන්නිවේදන පදනම මුදා හැරියේ ක්‍රේග් මැක්මර්ට්‍රි ISBN 0-672-32948-4

අවලංගු කළ හැකි අගය වර්ග

අගය වර්ගයක උදාහරණයකට අගයක් පවරා තිබේද යන්න දැන ගැනීමට කැමති පොදු අවස්ථා දෙකක් තිබේ. පළමුවැන්න දත්ත සමුදායක අගය නිරූපණය කරන විට ය. එවැනි අවස්ථාවක, දත්ත සමුදායේ වටිනාකමක් ඇත්ත වශයෙන්ම තිබේදැයි සොයා බැලීමට උදාහරණය පරීක්ෂා කිරීමට කෙනෙකුට අවශ්‍ය වේ. මෙම පොතේ විෂය කරුණු වලට වඩා අදාළ වන අනෙක් අවස්ථාව නම්, යම් දුරස්ථ ප්‍රභවයකින් ලැබෙන දත්ත අයිතමයක් උදාහරණය නිරූපණය කරන විට ය. නැවතත්, යමෙක් එම දත්ත අයිතමයට වටිනාකමක් ලැබුනේ දැයි නිශ්චය කිරීමට කැමති ය.

.NET Framework 2.0 හි සාමාන්‍ය වර්ගයේ අර්ථ දැක්වීමක් ඇතුළත් වන අතර එමඟින් වටිනාකම් වර්ගයක උදාහරණයකට ශුන්‍යය පැවරීමට අවශ්‍ය වන අවස්ථාවන් සඳහා සපයන අතර උදාහරණයේ වටිනාකම ශුන්‍ය දැයි පරීක්ෂා කරන්න. එම සාමාන්‍ය වර්ගයේ අර්ථ දැක්වීම System.Nullable වේ, එය T සඳහා අගය වර්ග සඳහා ආදේශ කළ හැකි සාමාන්‍ය වර්ගයේ තර්ක සීමා කරයි. System.Nullable වෙතින් සාදන ලද වර්ගවල අවස්ථා ශුන්‍ය අගයක් ලබා දිය හැකිය; ඇත්ත වශයෙන්ම, ඒවායේ අගයන් පෙරනිමියෙන් අහෝසි වේ. මේ අනුව, System.Nullable වෙතින් සාදන ලද වර්ග ශුන්‍ය වටිනාකම් වර්ග ලෙස හැඳින්විය හැක. System.Nullable හි දේපලක් ඇත, අගය, එමඟින් සාදන ලද වර්ගයක උදාහරණයකට පවරා ඇති අගය, එම අවස්ථාවෙහි අගය ශුන්‍ය නොවේ නම් ලබා ගත හැකිය. එබැවින් කෙනෙකුට ලිවිය හැකිය:

System.Nullable<int> myNullableInteger = null;
myNullableInteger = 1;
if (myNullableInteger != null)
{
Console.WriteLine(myNullableInteger.Value);
}

C # ක්‍රමලේඛන භාෂාව System.Nullable වෙතින් සාදන ලද වර්ග ප්‍රකාශ කිරීම සඳහා සංක්ෂිප්ත වාක්‍ය ඛණ්ඩයක් සපයයි. එම වාක්‍ය ඛණ්ඩය කෙටි කිරීමට කෙනෙකුට ඉඩ දෙයි:

System.Nullable<int> myNullableInteger;

වෙත

int? myNullableInteger;

සම්පාදකයා විසින් මේ ආකාරයෙන් අහෝසි කළ හැකි අගය වර්ගයක අගය සාමාන්‍ය අගය වර්ගයකට පැවරීමට උත්සාහ කිරීම වළක්වනු ඇත:

int? myNullableInteger = null;
int myInteger = myNullableInteger;

එය එසේ කිරීමෙන් වලක්වනුයේ ශුන්‍ය අගය වර්ගයට ශුන්‍ය අගයක් තිබිය හැකි නිසා එය ඇත්ත වශයෙන්ම මෙම අවස්ථාවේ දී තිබිය හැකි අතර එම අගය සාමාන්‍ය අගය වර්ගයකට පැවරිය නොහැකි බැවිනි. සම්පාදකයා මෙම කේතයට අවසර දුන්නද,

int? myNullableInteger = null;
int myInteger = myNullableInteger.Value;

System.Nullable.Value දේපල වෙත පිවිසීමට ගන්නා ඕනෑම උත්සාහයක් අවලංගු ක්‍රියාවක් වන බැවින් දෙවන ප්‍රකාශය ව්‍යතිරේකයක් විසි කිරීමට හේතු වේ. System.Nullable ට T හි වලංගු අගයක් පවරා නොමැති අතර එය සිදු වී නොමැත නඩුව.

නිගමනය:

ශුන්‍ය අගය වර්ගයක අගය සාමාන්‍ය අගය වර්ගයකට පැවරීම සඳහා එක් සුදුසු ක්‍රමයක් නම්, T හි වලංගු අගයක් ශුන්‍ය අගය වර්ගයට පවරා තිබේද යන්න සොයා බැලීම සඳහා System.Nullable.HasValue දේපල භාවිතා කිරීමයි:

int? myNullableInteger = null;
if (myNullableInteger.HasValue)
{
int myInteger = myNullableInteger.Value;
}

තවත් විකල්පයක් වන්නේ මෙම වාක්‍ය ඛණ්ඩය භාවිතා කිරීමයි:

int? myNullableInteger = null;
int myInteger = myNullableInteger ?? -1;

සාමාන්‍ය නිඛිල සංඛ්‍යාවක් වන myInteger හට වලංගු පූර්ණ සංඛ්‍යාවක් ලබා දී ඇත්නම්, “myNullableInteger” නම් කළ නොහැකි පූර්ණ සංඛ්‍යා වල අගය පවරනු ලැබේ; එසේ නොමැතිනම්, myInteger ට -1 හි අගය පවරනු ලැබේ.

එය ත්‍රිමාණ ක්‍රියාකරුට සමානව ක්‍රියා කරන ශුන්‍ය සිසිලන ක්‍රියාකරුවෙකි.

    a ?? b  => a !=null ? a : b 

මේ සඳහා තවත් සිත්ගන්නා කරුණක් නම්, “අහෝසි කළ හැකි වර්ගයක වටිනාකමක් තිබිය හැකිය, නැතහොත් එය නිර්වචනය කළ නොහැක” . එබැවින් ඔබ ශුන්‍ය නොවන අගය වර්ගයක් නොබැඳිය හැකි අගය වර්ගයකට පැවරීමට උත්සාහ කළහොත් ඔබට සම්පාදක කාල දෝෂයක් ලැබෙනු ඇත.

int? x = null; // x is nullable value type
int z = 0; // z is non-nullable value type
z = x; // compile error will be there.

ඉතින් ඒක පාවිච්චි කරන්න ?? ක්රියාකරු:

z = x ?? 1; // with ?? operator there are no issues

FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();

සමාන වේ

FormsAuth = formsAuth != null ? formsAuth : new FormsAuthenticationWrapper();

නමුත් එහි ඇති සිසිල්ම දෙය නම් අනෙක් අය කීවාක් මෙන් ඔබට ඒවා දම්වැල දැමිය හැකිය. සිහින් ස්පර්ශ නොකළ එකක් නම්, ව්‍යතිරේකයක් විසි කිරීමට ඔබට එය සැබවින්ම භාවිතා කළ හැකිය.

A = A ?? B ?? throw new Exception("A and B are both NULL");

මෙම ??ක්රියාකරු ශූන්ය-එක් රැස්වෙමින් ක්රියාකරු ලෙස හැඳින්වේ. ඔපෙරන්ඩ් ශුන්‍ය නොවේ නම් එය වම් අත ඔපෙරන්ඩ් යවයි; එසේ නොමැතිනම් එය දකුණු අත ක්‍රියාත්මක කරයි.

int? variable1 = null;
int variable2  = variable1 ?? 100;

ශුන්‍ය නොවේ නම් variable2එහි අගයට සකසන්න ; එසේ නොමැති නම් , 100 ට සකසන්න .variable1variable1variable1 == nullvariable2

තවත් සමහරු Null Coalescing Operatorඑය හොඳින් විස්තර කර ඇත. උනන්දුවක් දක්වන අය සඳහා, මෙය කෙටි කරන ලද වාක්‍ය ඛණ්ඩයක් ඇත (SO ප්‍රශ්නය):

FormsAuth = formsAuth ?? new FormsAuthenticationWrapper();

මෙයට සමාන වේ:

FormsAuth ??= new FormsAuthenticationWrapper();

සමහරු එය වඩාත් කියවිය හැකි සහ සාරාංශගත කරති.