මම නොබොබ්ස් සඳහා පිළිතුරක් එක් කරන්නේ මෙම පිළිතුරු මගේ හිසට ඉහළින් පෙනෙන නිසා එය කෙතරම් සරලදැයි මට වැටහෙන තුරු ය. සමහර විට එය සංකීර්ණ බව ඔබේ අපේක්ෂාව වන අතර එමඟින් 'ඔබේ හිස වටා එතීමට' නොහැකි වේ.
LINQ-to-SQL සාමාන්‍යයෙන් භාවිතා කිරීමට උත්සාහ කරන ඇත්තෙන්ම කරදරකාරී 'දෝෂයකට' යන තෙක් මට වෙනස තේරුම් ගැනීමට අවශ්ය නොවීය:
public IEnumerable<T> Get(Func<T, bool> conditionLambda){
using(var db = new DbContext()){
return db.Set<T>.Where(conditionLambda);
}
}
මම විශාල දත්ත කට්ටලවල OutofMemoryException ලබා ගැනීමට පටන් ගන්නා තෙක් මෙය විශිෂ්ටයි. ලැම්බඩා තුළ බ්‍රේක්පොයින්ට් සැකසීම මගේ මේසයේ සෑම පේළියක්ම එකින් එක මගේ ලැම්බඩා තත්වයට ගැලපෙන බව සොයමින් සිටින බව මට වැටහුණි. මෙය මා කලක සිට කම්පනයට පත් කළේය, මන්ද යත්, මගේ දත්ත වගුව දැවැන්ත IEnumerable ලෙස සලකන්නේ LINQ-to-SQL කිරීම වෙනුවට එය කළ යුත්තේ ඇයි? එය මගේ LINQ-to-MongoDb සහකරු තුළද එකම දේ කරමින් සිටියේය.
දෝෂ නිවැරදි හැරී හුදෙක් Func<T, bool>බවට Expression<Func<T, bool>>, ඒ නිසා එය අවශ්ය ඇයි මම googled Expressionවෙනුවට Funcමෙතන අවසන්.
ප්‍රකාශනයක් හුදෙක් නියෝජිතයෙකු තමා පිළිබඳ දත්ත බවට හරවයි. එබැවින් a => a + 1"වම් පැත්තේ එකක් ඇත int a. දකුණු පැත්තේ ඔබ එයට 1 ක් එක් කරයි." ඒක තමයි. ඔබට දැන් ගෙදර යා හැකිය. එය පැහැදිලිවම ඊට වඩා ව්‍යුහාත්මක ය, නමුත් එය අත්‍යවශ්‍යයෙන්ම ප්‍රකාශන ගසක් ඇත්තෙන්ම - ඔබේ හිස වටා එතීමට කිසිවක් නැත.
එය වටහා ගැනීමෙන්, LINQ-to-SQL ට අවශ්ය වන්නේ ඇයිද යන්න පැහැදිලි වන Expressionඅතර Funcඑය ප්‍රමාණවත් නොවේ. Funcඑය SQL / MongoDb / වෙනත් විමසුමකට පරිවර්තනය කරන්නේ කෙසේද යන්න පිළිබඳ විකාරරූපී බවක් දැකීමට එය තුළට ඇතුළු වීමට මාර්ගයක් ගෙන යන්නේ නැත. එය එකතු කිරීමක්ද, ගුණ කිරීමක්ද, අඩු කිරීමක්ද යන්න ඔබට නොපෙනේ. ඔබට කළ හැක්කේ එය ක්‍රියාත්මක කිරීමයි. Expression, අනෙක් අතට, නියෝජිතයා ඇතුළත බැලීමට සහ එය කිරීමට අවශ්ය සියල්ල බැලීමට ඔබට ඉඩ සලසයි. SQL විමසුමක් මෙන් ඔබට අවශ්ය ඕනෑම දෙයකට නියෝජිතයා පරිවර්තනය කිරීමට මෙය ඔබට බලය ලබා දෙයි. Funcමගේ DbContext ලැම්බඩා ප්‍රකාශනයේ අන්තර්ගතය අන්ධ බැවින් එය ක්‍රියාත්මක නොවීය. මේ නිසා, එයට ලැම්බඩා ප්රකාශනය SQL බවට හැරවීමට නොහැකි විය; කෙසේ වෙතත්, එය ඊළඟ හොඳම දේ කළ අතර මගේ වගුවේ එක් එක් පේළිය හරහා එම කොන්දේසිය නැවත ප්‍රකාශ කළේය.
සංස්කරණය කරන්න: ජෝන් පීටර්ගේ ඉල්ලීම පරිදි මගේ අවසාන වාක්‍යය පැහැදිලි කිරීම:
IQueryable IEnumerable දිගු කරයි, එබැවින් IEnumerable හි ක්‍රම Where()පිළිගන්නා අධික බර පැටවීම වැනි Expression. ඔබ ඒ සඳහා සමත් වූ Expressionවිට, ඔබ එහි ප්‍රති I ලයක් ලෙස IQueryable එකක් තබා ගනී, නමුත් ඔබ සමත් වූ විට Func, ඔබ IEnumerable පදනම මතට වැටෙන අතර එහි ප්‍රති I ලයක් ලෙස ඔබට IEnumerable ලැබෙනු ඇත. වෙනත් වචන වලින් කිවහොත්, ඔබ නොදැනුවත්වම ඔබේ දත්ත කට්ටලය විමසීමට යමක් වෙනුවට නැවත සැකසිය යුතු ලැයිස්තුවක් බවට පත් කර ඇත. ඔබ අත්සන් දෙස බැලූ විට වෙනසක් දැකීම දුෂ්කර ය.
විශාල රූපය