IEnumerable Ezali Te Oyo Okanisi Ezali —Mpe Ezali Kobuka Code Na Yo

TLDR: Totala na bozindo libunga oyo emonanaka mingi na oyo etali IEnumerable - botangi mbala na mbala - kasi mbala oyo tokokende mwa moke na mozindo mpe tokotala lisusu mpo na nini botangi ya mbala na mbala ezali libunga mpe mikakatano nini ya potentiel ekoki kobimisa, bakisa mpe ba bugs oyo ezali mpasi mpo na kokanga mpe kozongisa.

Oyo IEnumerable ezali

Makambo ya liboso liboso - totala lisusu (encore encore, lokola ezali na ba articles assez ebele na likambo oyo) nini IEnumerable, ezala générique mpe non générique, ezali. Ba développeurs mingi, ndenge ba interviews ebele na ba revues ya code elakisaka, sans ko yeba ba instances ya IEnumerable batalaka lokola ba collections, pe awa nde tokobanda.

Tango totali définition ya interface ya IEnumerable, awa ezali oyo tomoni:

 public interface IEnumerable<out T> : IEnumerable { IEnumerator<T> GetEnumerator(); }

Tokokota na makambo ya mikemike ya ba enumerateurs mpe bongo na bongo te; ekoki koloba likambo moko ya ntina mingi: IEnumerable ezali lisanga te . Mitindo mingi ya bosangisi esalelaka IEnumerable, kasi yango ebongoli te bosaleli nyonso ya IEnumerable na bosangisi. Likambo ya kokamwa, oyo ezali oyo ba développeurs mingi bazangaka tango ba mettre en œuvre code consommateur to produisant IEnumerable, mpe yango nde ezali na potentiel munene ya ba problèmes.

Bongo, IEnumerable ezali nini? Ezali na ba implémentations ebele ya ndenge na ndenge pona IEnumerable, kasi pona bolamu ya pete tokoki ko résumer yango na définition moko (plutôt vague) : ezali eteni ya code oyo ebimisaka ba éléments na iterations. Mpo na ba collections na kati ya mémoire code oyo elingaki kaka kotanga élément ya lelo uta na collection ya sous-jacent mpe kokende na pointeur na yango ya kati na élément oyo elandi, soki ezali. Pona ba cas ya sophistiqué mingi logique ekoki kozala très variée, pe ekoki kozala na ba effets secondaires ya ndenge nionso oyo ekoki pe kozala na ko modifier état partagé, to ko dépendre na état partagé.

Sikoyo tozali na elilingi ya mwa malamu koleka ya nini IEnumerable ezali, mpe yango ezali kopesa biso likanisi ya kosalela code oyo ezali kolya na ndenge oyo esengeli te kosala ata makanisi moko te na makambo oyo:

• ntalo oyo esengeli mpo na kobimisa biloko - elingi koloba soki eloko moko ezwamaki na lolenge moko ya kobombama (esalelamaki lisusu) to esalemaki ;
• eloko yango moko ekoki kobimisama lisusu na ba iterations oyo elandi;
• ba effets secondaires nionso oyo ekoki kozala na bopusi (to te) ba iterations oyo elandi.

Ndenge tokoki komona yango, yango ezali pene na kokesana na mibeko ya monene ntango ozali kozongela makambo oyo ezali na kati ya mémoire, na ndakisa:

• lisanga ekoki kobongisama te na tango ya iterations - soki lisanga ebongisami, yango ekosala exception tango ya kokende na élément oyo elandi na collection;
• kosala mbala na mbala likolo ya liboke moko (oyo ezali na biloko ndenge moko) ekobimisa ntango nyonso mbano ndenge moko mpe ekozala ntango nyonso na ntalo ndenge moko.

Lolenge ya libateli ya kotala IEnumerable ezali ya ko percevoir yango lokola 'producteur ya ba données sur demande'. Garantie seule oyo producteur ya ba données oyo apesaka ezali que soit eko procurer eloko mosusu soit eko signaler que biloko ezali lisusu te tango bakobenga yango. Nionso mosusu ezali ba détails ya mise en œuvre ya producteur ya ba données particulières. Par ailleurs, awa to décrire contrat ya interface ya IEnumerator oyo epesaka nzela ya ko iterer likolo ya instance IEnumerable.

Eteni mosusu ya ntina ya mobimisi ya ba données na demande ezali ete ebimisaka eloko moko na iterations moko, mpe code oyo esalelaka ekoki kozwa mokano soki elingi kosilisa eloko nyonso oyo mobimisi azali na makoki ya kobimisa to kopekisa bomeli yango liboso. Lokola ba producteurs ya ba données sur demande bamekaki kutu te kosala na biloko oyo ekoki kozala ‘avenir’, yango epesaka nzela ya kobomba ba ressources tango consommation esili liboso ya tango.

Donc, tango tozali ko mettre en œuvre ba producteurs IEnumerable, esengeli jamais tosala ba suppositions moko te na ba modèles ya consommation. Ba consommateurs bakoki kobanda pe kotika consommation na point nionso.

Ba effets potentiels ya ba iterations oyo ezongaka mbala na mbala.

Sikawa, lokola tosili kolimbola lolenge malamu ya kolya IEnumerable, tótalela mwa bandakisa ya ba iterations oyo ezongelami mbala na mbala mpe bopusi na yango oyo ekoki kozala.

Yambo tokende na ba exemples négatifs, ezali na tina ya koloba que tango IEnumerable ezo impersoner collection in-mémoire - array, liste, hashset, etc. - ezali na mabe moko te na ba iterations repetitives per se. Code oyo ezo consommer IEnumerable likolo ya ba collections in-mémoire na ba cas mingi elingaki ekende (pene na) na ndenge ya malamu lokola code oyo ezo consommer ba types ya collection oyo ekokani. Ya solo, ekoki kozala na bokeseni na makambo mosusu, atako ezali mpenza mabe te, lokola Linq emoni ba boosts ya performance ya minene mingi oyo ekopesa nzela, na ndakisa, kosalela ba instructions ya CPU vectorisées mpo na ba collections na kati ya mémoire to ba appels ya méthode ya interface multiple compacte na kati ya moko mpo na ba expressions complexes ya Linq. Svp tanga masolo oyo mpo na koyeba makambo mosusu: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-8/#linq mpe https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-9/#linq

Kasi, na point de vue ya qualité ya code, kozala na ba iterations ebele likolo ya IEnumerable etalelami lokola pratique ya mabe, lokola tokoki jamais kozala sûr que mise en œuvre nini ya béton ekokoma na se ya capote.

Tango iterations oyo ezongelami ezali vraiment choix ya mabe.

Eteni oyo ya code ezalaki kozwa ba données na esika ya suka ya mosika mpo na liste ya ba paramètres oyo ekoti.

 async Task<IEnumerable<IData>> RetrieveAndProcessDataAsync(IList<int> ids, CancellationToken ct) { var retrievalTasks = ids.Select(id => externalService.QueryForDataAsync(id, ct)); await Task.WhenAll(retrievalTasks); return retrievalTasks.Select(t => t.Result); }

Nini ekoki kokende mabe awa? Tózongela ndakisa oyo eleki pɛtɛɛ:

 var results = await RetrieveAndProcessDataAsync(ids, cancellationToken); var output = results.ToArray();

Ba développeurs mingi bako considérer code oyo sûr - po epekisaka ba iterations repetitives en matérialiser sortie ya méthode na collection in-mémoire. Kasi, ezali bongo?

Avant to kota na ba détails tosala test run. Tokoki kozua mise en œuvre moko ya pete mingi ya 'externalService' pona komeka:

 record Data(int Value); class Service { private static int counter = 0; public async Task<IData> QueryForDataAsync(int id, CancellationToken ct) { var timestamp = Stopwatch.GetTimestamp(); await Task.Delay(TimeSpan.FromMilliseconds(30), ct); int cv = Interlocked.Increment(ref counter); Console.WriteLine($"QueryForData - id={id} - {cv}; took {Stopwatch.GetElapsedTime(timestamp).TotalMilliseconds:F0} ms"); return new Data(id); } }

Na nsima, tokoki kosala momekano yango:

 var externalService = new Service(); var results = (await RetrieveAndProcessDataAsync([1, 2, 3], CancellationToken.None)).ToList(); Console.WriteLine("Querying completed"); int count = results.Count(); if (count == 0) { Console.WriteLine("No results"); } else { var array = results.ToArray(); Console.WriteLine($"Retrieved {array.Length} elements"); } Console.WriteLine($"Getting the count again: {results.Count()}");

Mpe zwa sortie:

 QueryForData - id=3 - 1; took 41 ms QueryForData - id=1 - 3; took 43 ms QueryForData - id=2 - 2; took 42 ms QueryForData - id=1 - 4; took 33 ms QueryForData - id=2 - 5; took 30 ms QueryForData - id=3 - 6; took 31 ms Querying completed Retrieved 3 elements Getting the count again: 3

Eloko moko ezali mosika awa, boye te? Tolingaki kozela kozwa sortie ya 'QueryForData' kaka mbala 3, lokola tozali kaka na 3 ids na argument ya entrée. Kasi, sortie elakisaka polele que nombre ya ba exécutions e doubler même avant appel ToList() esila.

Mpo na kososola ntina, totala lolenge ya RetrieveAndProcessDataAsync:

 1: var retrievalTasks = ids.Select(id => externalService.QueryForDataAsync(id, ct)); 2: await Task.WhenAll(retrievalTasks); 3: return retrievalTasks.Select(t => t.Result);

Mpe totala libiangi oyo:

 (await RetrieveAndProcessDataAsync([1, 2, 3], CancellationToken.None)).ToList();

Tango méthode RetrieveAndProcessDataAsync ebengami, makambo oyo elandi esalemaka.

Na ligne 1 tozuaka instance IEnumerable<Task<Data>> - na cas na biso, ekozala 3 tâches, puisque to soumettre array ya entrée na 3 éléments. Mosala moko na moko ezuaka molongo na pool ya thread mpo na exécution, mpe soki kaka thread ezali, ebandi. Point ya bosilisi ya sikisiki mpo na misala oyo eyebani te mpo na makambo ya sikisiki ya programmation ya pool ya thread mpe matériel béton oyo code oyo elingaki kotambola na yango.

Na ligne 2 appel ya Task.WhenAll esalaka que misala nionso oyo ewutaki na instance IEnumerable<Task<Data>> ekomi na bosilisi; essentiellement, na point oyo tozuaka ba sorties 3 ya liboso na méthode QueryForDataAsync. Tango ligne 2 esili, tokoki kozala sûr que misala nionso 3 esilisi lokola.

Kasi, ligne 3 ezali esika ba diables nionso ba tiaki embuscade. Totimola bango libanda.

Variable 'retrievalTasks' (na ligne 1) ezali instance IEnumerable<Task<Data>> . Sikawa, tozonga sima mpe tomikundola ete IEnumerable ezali eloko mosusu te kasi mobimisi - eteni ya code oyo ebimisaka (ezali kosala to esalelaka lisusu) ba instances ya lolenge moko epesami. Na cas oyo variable 'retrievalTasks' ezali eteni ya code oyo elingaki:

• kende likolo ya liboke ya 'ids';
• mpo na eloko moko na moko ya lisanga oyo, ekobenga méthode externalService.QueryForDataAsync;
• zongisa instance ya Task oyo ebimisami na appel ya liboso.

Tokoki ko exprimer logique oyo nionso sima ya instance na biso IEnumerable<Task<Data>> mua ndenge mosusu. Svp sala note que alors que pièce ya code oyo ezo monana assez différente na expression originale ids.Select(id => externalService.QueryForDataAsync(id, ct)) , esalaka exactement ndenge moko.

 IEnumerable<Task<Data>> DataProducer(IList<int> ids, CancellationToken ct) { foreach (int id in ids) { var task = externalService.QueryForData(id, ct); yield return task; } }

Donc, tokoki ko traité variable 'retrievalTasks' lokola appel ya fonction na ensemble constant prédéfini ya ba entrées. Fonction oyo elingaki kobengama mbala nionso to résoudre valeur ya variable. Tokoki kokoma lisusu méthode RetrieveAndProcessDataAsync na ndenge oyo ekomonisa mobimba likanisi oyo, mpe oyo ekosala mpenza ndenge moko na bosaleli ya ebandeli:

 async Task<IEnumerable<Data>> RetrieveAndProcessDataAsync(IList<int> ids, CancellationToken ct) { var retrievalFunc = () => DataProducer(ids, ct); await Task.WhenAll(retrievalFunc()); return retrievalFunc().Select(t => t.Result); }

Sikoyo tokoki komona très clairement pourquoi sortie ya code ya test na biso e doubler : fonction 'retrievalFunc' ezuaka appel deux fois... Soki code na biso ya consommateur ezo continuer koleka na même instance IEnumerable, eko égaliser ba appels répétitifs na méthode 'DataProducer', oyo elingaki e tambuisa logique na yango mbala na mbala pona chaque re-iteration.

Nazali na espoir sikoyo logique oyo ezali sima ya ba iterations répétitives ya IEnumerable ezali clair.

Implications mosusu oyo ekoki kozala ya ba iterations oyo ezongaka mbala na mbala.

Ezali naino na likambo moko ya kolobela na ntina na échantillon oyo ya code, nzokande.

Totala lisusu mise en œuvre oyo ekomami lisusu:

 IEnumerable<Task<Data>> DataProducer(IList<int> ids, CancellationToken ct) { foreach (int id in ids) { var task = externalService.QueryForData(id, ct); yield return task; } } async Task<IEnumerable<Data>> RetrieveAndProcessDataAsync(IList<int> ids, CancellationToken ct) { var retrievalFunc = () => DataProducer(ids, ct); await Task.WhenAll(retrievalFunc()); // First producer call. return retrievalFunc().Select(t => t.Result); // Second producer call. }

Producteur na cas oyo asala ba instances ya sika ya misala mbala nionso, pe tobengi yango mbala mibale. Yango ememaka na likambo moko ya plutôt particulier mpe ya polele te que tango tobengi Task.WhenAll na .Select(t => t.Result) ba instances ya tâche ba pièces de code mibale oyo esalaka na yango ekeseni. Misala oyo ezelamaki (mpe bongo ekomaki kino na bosilisi) ezali misala moko te oyo lolenge yango ezongisaka mbano uta na yango.

Donc, awa producteur a créer deux ensembles différents ya ba tâches. Ensemble ya liboso ya misala ezelamaka na ndenge ya asynchrone - kobenga Task.WhenAll - kasi ensemble ya mibale ya misala ezelamaka te. Au lieu ya kosala bongo, code ebengi directement na getter ya propriété Result oyo ezali efficacement anti-modèle infame sync-over-async. Nalingaki kokende na ba détails ya anti-modèle oyo te, lokola oyo ezali sujet munene. Lisolo oyo ya Stephen Toub epesi mwa pole na yango: https://devblogs.microsoft.com/pfxteam/esengeli-na-exposer-ba enveloppes- synchrone-pour-méthodes-asynchrone/

Kasi, kaka mpo na kozala na mobimba, talá mwa makambo oyo ekoki kobima code oyo ekoki kobimisa:

• ba impasse, tango esalelami na bureau (WinForms, WPF, MAUI) to ba applications .Net Fx ASP.NET;
• nzala ya piscine ya fil tango na se ya ba charges ya likolo.

Soki to abstraire na échantillon ya code ya lelo oyo ezalaki kobimisa misala wana ya pete, tozali kokutana na likambo oyo ete ba iterations oyo ezongelami ekoki kosala na pete ba exécutions ebele mpo na opération nionso, mpe ekoki kozala idempotent te (elingi koloba, ba appels oyo elandi na ba entrées moko ezali bound na kobimisa ba résultats différents to même kaka kozanga). Na ndakisa, solde ya compte ebongwanaka.

Ata soki ba opérations wana ezalaki idempotent, ekoki kozala na ba coûts ya calcul ya likolo, mpe bongo exécution na yango mbala na mbala ekozikisa kaka ba ressources na biso pamba. Mpe soki tolobeli code oyo ezali kotambola na lipata, ba ressources oyo ekoki kozala na coût oyo tolingaki kofuta.

Encore, lokola ba iterations repetitives sur les instances IEnumerable ezali assez facile ya kozanga, ekoki kozala très difficile ya koyeba pourquoi application moko ezo crasher, ezo dépenser ba ressources ebele (y compris mbongo), to ezo sala makambu oyo esengelaki esala te.

Kosala makambo ya elɛngi kaka mwa moke.

Tozua code ya test original pe to changer yango mua moke:

 var externalService = new Service(); var cts = new CancellationTokenSource(); // New line. var results = (await RetrieveAndProcessDataAsync([1, 2, 3], cts.Token)); // Using cts.Token instead of a default token, and not materializing the IEnumerable. Console.WriteLine("Querying completed"); int count = results.Count(); if (count == 0) { Console.WriteLine("No results"); } else { var array = results.ToArray(); Console.WriteLine($"Retrieved {array.Length} elements"); } cts.Cancel(); // New line. Console.WriteLine($"Getting the count again: {results.Count()}");

Nakotika yango na motángi ameka mpe atambwisa code oyo. Ekozala elakiseli malamu ya ba effets secondaires oyo ekoki kozala ba iterations oyo ezongaka mbala na mbala ekoki kokutana na yango na mbalakaka.

Ndenge nini kobongisa code oyo?

Totala naino:

 async Task<IEnumerable<IData>> RetrieveAndProcessDataAsync(IList<int> ids, CancellationToken ct) { var retrievalTasks = ids.Select(id => externalService.QueryForDataAsync(id, ct)).ToArray(); // Adding .ToArray() call. await Task.WhenAll(retrievalTasks); return retrievalTasks.Select(t => t.Result); }

Na kobakisa kobenga moko ya .ToArray() na IEnumerable<Task<Data>> ya ebandeli tolingaki ‘matérialiser’ instance ya IEnumerable na kati ya collection na kati ya mémoire, mpe ba ré-iterations nionso oyo elandi likolo ya collection na mémoire esalaka exactement oyo tokokanisa - kotanga kaka ba données na mémoire sans ba effets secondaires imprévus oyo euti na ba exécutions ya code oyo ezongelami.

Essentiellement, tango ba développeurs bakomaka code ya boye (lokola na échantillon ya code ya liboso), normalement ba présumer que ba données oyo ‘etiamaki na libanga’, mpe eloko moko te oyo ekanisamaki te elingaki kosalema tango ba accéder na yango. Atako, lokola touti komona yango, likambo yango ezali mpenza mosika na solo.

Tokokaki kobongisa lisusu lolenge yango, kasi tokotika likambo oyo mpo na mokapo oyo ekolanda.

Na kobimisa IEnumerable moko.

Totali kaka makambo oyo ekoki kobima na bosaleli ya IEnumerable tango etongami na makanisi ya mabe - tango ezuaka na makanisi te que ata moko te ya ba suppositions oyo esengeli esalama tango ya ko consommer IEnumerable:

• ntalo oyo esengeli mpo na kobimisa biloko - elingi koloba soki eloko moko ezwamaki na lolenge moko ya kobombama (esalelamaki lisusu) to esalemaki ;
• soki eloko moko ekoki kobimisama lisusu na ba iterations oyo elandi;
• ba effets secondaires nionso oyo ekoki kozala na bopusi (to te) ba iterations oyo elandi.

Sikoyo, totala elaka oyo ba producteurs IEnumerable basengeli (na ndenge ya malamu) kobatela mpo na ba consommateurs na bango:

• biloko ebimaka 'na demande' - effort moko te esengeli esalama 'avance' ;
• ba consommateurs bazali na bonsomi ya kotika iterations na moment nionso, mpe yango esengeli kobikisa ba ressources oyo ekosenga soki consommation ekobi ;
• soki iterations (consommation) ebandi te, esengeli kosalela ba ressources te.

Encore, totala échantillon ya code na biso ya kala na point de vue oyo.

 async Task<IEnumerable<IData>> RetrieveAndProcessDataAsync(IList<int> ids, CancellationToken ct) { var retrievalTasks = ids.Select(id => externalService.QueryForDataAsync(id, ct)).ToArray(); await Task.WhenAll(retrievalTasks); return retrievalTasks.Select(t => t.Result); }

Essentiellement, code oyo ekokisaka ba promesses wana te, lokola ba levage durs nionso esalemaka na deux lignes ya liboso, avant ebandaki kobimisa IEnumerable. Donc, soki consommateur moko ako décider kotika consommation liboso, to même akobanda yango ata muke te, méthode QueryForDataAsync elingaki kaka kobengama pona ba entrées nionso.

Soki totali bizaleli ya milɔngɔ mibale ya liboso, ekozala malamu mingi kokoma lisusu lolenge yango mpo na kobimisa liboke oyo ezali na kati ya mémoire, na ndakisa:

 async Task<IList<IData>> RetrieveAndProcessDataAsync(IList<int> ids, CancellationToken ct) { var retrievalTasks = ids.Select(id => externalService.QueryForDataAsync(id, ct)).ToArray(); await Task.WhenAll(retrievalTasks); return retrievalTasks.Select(t => t.Result).ToArray(); }

Bosaleli oyo epesi garantie moko te ya 'na demande' - au contraire, ezali polele mingi ete mosala nionso oyo esengeli pona kosala entrée oyo epesami elingaki kosila, pe ba résultats oyo ekokani elingaki kozongisama.

Kasi, soki tozali na mposa ya comportement ya ‘producteur ya ba données sur demande’, esengelaki kokoma lisusu méthode mobimba mpo na kopesa yango. Na ndakisa:

 async IAsyncEnumerable<Data> RetrieveAndProcessDataAsAsyncEnumerable(IList<int> ids, [EnumeratorCancellation] CancellationToken ct) { foreach (int id in ids) { var result = await externalService.QueryForData(id, ct); yield return result; } }

Alors que ba développeurs mbala mingi bakanisaka te na ba spécificités oyo ya contrat ya IEnumerable, code mosusu oyo ezo consommer yango mbala mingi elingaki kosala ba suppositions oyo ekokani na ba spécificités wana. Donc, tango code oyo ebimisaka IEnumerable ekokani na ba spécificités wana, application mobimba elingaki esala malamu.

Maloba ya nsuka.

Nazali na elikya ete lisolo oyo esalisaki motángi amona bokeseni kati na contrat ya collecte mpe ba spécificités ya contrat IEnumerable. Mingimingi, masangani epesaka mwa ebombelo mpo na biloko na yango (mbala mingi, na mémoire) mpe banzela ya koleka likoló ya biloko oyo ebombami; ba collections non-readonly ebakisaka pe contrat oyo na kopesaka nzela ya ko modifier/kobakisa/kolongola biloko oyo ebombami. Atako ba collections ezali très constant na oyo etali biloko oyo ebombami, IEnumerable essentiellement esakolaka volatilité ya likolo mingi na likambo oyo puisque biloko ebimaka tango instance IEnumerable ezo iterer likolo.

Donc, nini ekozala ba meilleurs pratiques tango okoya na IEnumerable? Topesa kaka liste ya ba points:

• Bokima tango nionso ba iterations oyo ezongaka mbala na mbala - longola se soki oyo ezali oyo okani vraiment pe o comprendre ba conséquences. Ezali na likama te ko chaîner ba méthodes ya extension ya Linq ebele na instance IEnumerable (lokola .Where na .Select ) kasi appel mosusu nionso oyo ekosala iterations ya solo ezali eloko ya ko éviter. Soki logique ya traitement esengaka ba passes ebele likolo ya IEnumerable, soit ko materialiser yango na collection in-mémoire soit revoir soki logique ekoki ko changer na passe moko na ba bases ya eloko moko.
• Tango kobimisa IEnumerable esangisi code async, kanisá kobongola yango na IAsyncEnumerable to kozongisa IEnumerable na esika ya representation 'materialisé' - ndakisa, tango okolinga ko profiter na exécution parallèle, mpe kozongisa ba résultats sima ya misala nionso.
• Esengeli kotonga IEnumerable oyo ebimisaka code na ndenge oyo ekopesa nzela ya koboya kobimisa ba ressources soki iterations ekotelema liboso to ekobanda ata moke te.
• Kosalela IEnumerable te mpo na mitindo ya ba données longola se soki ozali na mposa ya makambo na yango ya sikisiki. Soki code na yo esengeli na mwa degré ya 'généralisation', préférer ba interfaces mosusu ya type collection oyo elingi koloba te comportement ya 'producteur ya ba données sur demande', lokola IList to IReadOnlyCollection.