C # හි විචල්‍යය පුරෝකථනයක නැවත භාවිතා කිරීමට හේතුවක් තිබේද?

C # හි ලැම්බඩා ප්‍රකාශන හෝ නිර්නාමික ක්‍රම භාවිතා කරන විට, නවීකරණය කරන ලද වසා දැමීමේ වළල්ලට ප්‍රවේශ වීම ගැන අප සැලකිලිමත් විය යුතුය . උදාහරණයක් වශයෙන්:

foreach (var s in strings)
{
   query = query.Where(i => i.Prop == s); // access to modified closure
   ...
}

නවීකරණය කරන ලද වසා දැමීම හේතුවෙන්, ඉහත කේතය මඟින් Whereවිමසුමේ ඇති සියලුම වගන්තිවල අවසාන අගය මත පදනම් වේ s.

ලෙස පැහැදිලි මෙතන , මේ සිදු වන නිසා sවිචල්ය දී ප්රකාශයට පත් කරන foreachසම්පාදකවරයා මේ වගේ පරිවර්ථනය කර ඇත ඉහත පුඩුවක්:

string s;
while (enumerator.MoveNext())
{
   s = enumerator.Current;
   ...
}

මේ වෙනුවට:

while (enumerator.MoveNext())
{
   string s;
   s = enumerator.Current;
   ...
}

මෙහි පෙන්වා දී ඇති පරිදි , ලූපයෙන් පිටත විචල්‍යයක් ප්‍රකාශ කිරීමේ කාර්ය සාධන වාසි නොමැති අතර සාමාන්‍ය තත්වයන් යටතේ මෙය කිරීමට මට සිතිය හැකි එකම හේතුව වන්නේ ඔබ ලූපයේ විෂය පථයෙන් පිටත විචල්‍යය භාවිතා කිරීමට අදහස් කරන්නේ නම්:

string s;
while (enumerator.MoveNext())
{
   s = enumerator.Current;
   ...
}
var finalString = s;

කෙසේ වෙතත්, ලූපයක අර්ථ දක්වා ඇති විචල්‍යයන් ලූපයෙන් foreachපිටත භාවිතා කළ නොහැක:

foreach(string s in strings)
{
}
var finalString = s; // won't work: you're outside the scope.

එබැවින් සම්පාදකයා විසින් විචල්‍යය ප්‍රකාශයට පත් කරනුයේ එය බොහෝ විට සොයාගත හැකි හා නිදොස්කරණය කිරීමට අපහසු වන දෝෂයකට බෙහෙවින් නැඹුරු වන අතර කිසිදු ප්‍රතිලාභයක් නොලැබෙන බැවිනි.

ඔබ සමඟ කළ හැකි යමක් තිබේද foreachඔබ ඔවුන් අභ්යන්තර-scoped විචල්ය සමඟ සම්පාදනය නොහැකි නම්, බව මේ ආකාරයට වළළු, හෝ මෙම නිර්නාමික ක්රම සහ ලැම්ඩා ප්රකාශන ලබා ගත හැකි හෝ පොදු විය පෙර සිදු වූ බව පමණක් හිතුවක්කාරී තේරීම වන අතර, වන hasn එතැන් සිට සංශෝධනය කර නැද්ද?

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

ඔබේ විවේචනය මුළුමනින්ම යුක්ති සහගත ය.

මම මෙම ගැටලුව මෙහි විස්තරාත්මකව සාකච්ඡා කරමි:

හානිකර යැයි සැලකෙන ලූප් විචල්‍යය වසා දැමීම

Foreach loops මඟින් ඔබට අභ්‍යන්තර පරිමාණ විචල්‍යයක් සමඟ සම්පාදනය කර ඇත්නම් ඔබට කළ නොහැකි දෙයක් තිබේද? නැතහොත් මෙය නිර්නාමික ක්‍රම සහ ලැම්බඩා ප්‍රකාශන ලබා ගැනීමට පෙර හෝ පොදු වූ අතර එතැන් සිට සංශෝධනය නොකළ අත්තනෝමතික තේරීමක් ද?

පසු. සී # 1.0 පිරිවිතරයේ ඇත්ත වශයෙන්ම ලූප් විචල්‍යය ලූප් ශරීරය තුළ හෝ පිටත තිබේද යන්න නොකියයි. C # 2.0 හි සංවෘත අර්ථකථන හඳුන්වා දුන් විට, "for" පුඩුවට අනුකූලව ලූප විචල්‍යය ලූපයෙන් පිටත තැබීමට තෝරා ගන්නා ලදී.

සියලු දෙනා එම තීරණය ගැන කනගාටු වන බව පැවසීම සාධාරණ යැයි මම සිතමි. මෙය C # හි ඇති නරකම "ගොචා" වලින් එකක් වන අතර, එය නිවැරදි කිරීම සඳහා අපි බිඳීමේ වෙනස ගැනීමට යන්නෙමු. C # 5 දී foreach ලූපය විචල්ය තර්කානුකූලව වනු ඇත තුල කම්බියක් ශරීරය, එම නිසා වසා නැවුම් පිටපතක් සෑම අවස්ථාවකදීම ලැබෙනු ඇත.

මෙම forලූපය වෙනස් කරනු ලබන්නේ නැත, සහ වෙනස් C # හි පෙර අනුවාදයකින් කිරීමට "නැවත ප්රදර්ශනය කරනු ලබන්නේ" කළ නොහැකි වනු ඇත. එබැවින් මෙම මෝඩකම භාවිතා කිරීමේදී ඔබ දිගටම ප්‍රවේශම් විය යුතුය.

ඔබ ඉල්ලන දේ එරික් ලිපර්ට් සිය බ්ලොග් සටහනේ හොඳින් ආවරණය කරයි හානිකර යැයි සැලකෙන ලූප් විචල්‍යය සහ එහි අනුප්‍රාප්තිකය වසා දැමීම .

මට නම්, වඩාත් ඒත්තු ගැන්වෙන තර්කය නම්, එක් එක් පුනරාවර්තනයේ නව විචල්‍යයක් තිබීම for(;;)ස්ටයිල් ලූපයට නොගැලපෙන බවයි. int iඑක් එක් පුනරාවර්තනයේ දී නව එකක් ලබා ගැනීමට ඔබ අපේක්ෂා for (int i = 0; i < 10; i++)කරනවාද?

මෙම හැසිරීමේ වඩාත් පොදු ගැටළුව වන්නේ පුනරාවර්තන විචල්‍යයට වඩා වසා දැමීම වන අතර එයට පහසු ක්‍රියාමාර්ගයක් ඇත:

foreach (var s in strings)
{
    var s_for_closure = s;
    query = query.Where(i => i.Prop == s_for_closure); // access to modified closure

මෙම ගැටලුව පිළිබඳ මගේ බ්ලොග් සටහන: C # හි foreach විචල්‍යය වසා දැමීම .

මෙයින් සපා කා ඇති බැවින්, ඕනෑම වසා දැමීමකට මාරු කිරීම සඳහා මා භාවිතා කරන අභ්‍යන්තර විෂය පථයට දේශීයව අර්ථ දක්වා ඇති විචල්‍යයන් ඇතුළත් කිරීමේ පුරුද්දක් මට ඇත. ඔබේ උදාහරණයේ:

foreach (var s in strings)
    query = query.Where(i => i.Prop == s); // access to modified closure

මම කරනවා:

foreach (var s in strings)
{
    string search = s;
    query = query.Where(i => i.Prop == search); // New definition ensures unique per iteration.
}        

ඔබට එම පුරුද්ද ඇති වූ පසු, ඔබ සැබවින්ම බාහිර විෂය පථයන්ට බැඳීමට අදහස් කළ ඉතා දුර්ලභ අවස්ථාවකදී එය වළක්වා ගත හැකිය . ඇත්තම කිව්වොත් මම හිතන්නේ නැහැ මම කවදාවත් එහෙම කරලා නැහැ කියලා.

C # 5.0 හි, මෙම ගැටළුව නිරාකරණය කර ඇති අතර ඔබට ලූප විචල්‍යයන් වසා දමා ඔබ අපේක්ෂා කරන ප්‍රති results ල ලබා ගත හැකිය.

භාෂා පිරිවිතරයේ මෙසේ සඳහන් වේ:

8.8.4 පුරෝකථන ප්‍රකාශය

(...)

පෝරමයේ පුරෝකථන ප්‍රකාශයක්

foreach (V v in x) embedded-statement

ඉන්පසු පහත පරිදි පුළුල් වේ:

{
  E e = ((C)(x)).GetEnumerator();
  try {
      while (e.MoveNext()) {
          V v = (V)(T)e.Current;
          embedded-statement
      }
  }
  finally {
      … // Dispose e
  }
}

(...)

vකාවැද්දූ ප්‍රකාශයේ සිදුවන ඕනෑම නිර්නාමික ශ්‍රිතයක් මගින් එය ග්‍රහණය කරගන්නේ කෙසේද යන්න සඳහා කාල ලූපය තුළ ස්ථානගත කිරීම වැදගත් වේ. උදාහරණයක් වශයෙන්:

int[] values = { 7, 9, 13 };
Action f = null;
foreach (var value in values)
{
    if (f == null) f = () => Console.WriteLine("First value: " + value);
}
f();

නම් vවූ අතර, ලූප පිටත ප්රකාශයට පත් කරන ලදි, ඒ සියල්ල අනුකරණ අතර හවුල් වීම සහ පුඩුවක් සඳහා පසු එහි අගය අවසන් අගය, වනු ඇත 13පිලිබඳ යාදින්න දේ වන, fමුද්රණය ඇත. ඒ වෙනුවට, එක් එක් නැවතීමේ ක්‍රියාවලියට තමන්ගේම විචල්‍යයක් ඇති හෙයින්, පළමු පුනරාවර්තනයේදී vග්‍රහණය කරගත් fඅගය දිගටම අගය රඳවා තබා ගනී 7, එය මුද්‍රණය කරනු ලැබේ. ( සටහන: C # හි පෙර සංස්කරණ කාල ලූපයෙන් vපිටත ප්‍රකාශයට පත් කරන ලදි. )