Différence majeure entre Foreach et Using

Question

Cela pourrait même être une question simple à laquelle même un écolier peut répondre.

Quelles sont les similitudes et les différences entre & "ForEach &"; et " Utilisation de " (demandé dans une interview).

Mon hypothèse était

1) Les deux sont énumérables

2) L'utilisation peut gérer les ressources de mémoire, mais foreach ne peut pas.utiliser utilise IDisposable, pour ne pas.

Je souhaite connaître les réponses.

Answer 1

Similitudes:

• ce sont tous deux des extensions de code logique, fournissant le code de chaudière de scénarios autrement complexes
• impliquent tous deux une variable cachée introduite par le compilateur: pour l'itérateur et l'instantané de l'objet jetable, respectivement

Mais c'est à peu près là où ça se termine ...

• using exige IDisposable; foreach pourrait se déclencher à partir de IEnumerable[<T>], mais est en fait saisi par un canard (vous n'avez pas besoin de IEnumerable pour try)
• finally a une construction prévisible Dispose() / IEnumerable<T>; lock pourrait impliquer un <=> si l'itérateur est <=>

Si quoi que ce soit, je dirais que <=> est plus proche de <=> que de <=>.

Answer 2

1. Nope
2. Nope, foreach éliminera votre IEnumerable s'il implémente IDisposable.

Answer 3

using définit une portée en dehors de laquelle un ou plusieurs objets seront supprimés. Il ne fait ni boucle ni itération.

Answer 4

Ils servent tous deux des objectifs très différents.

foreach est fait pour énumérer les éléments d'une collection / tableau. using est une construction pratique pour vous assurer que vous disposez correctement de ce que vous utilisez. Même lorsque des exceptions sont levées, par exemple.

Les similitudes entre ces deux constructions sont justes, étranges. Quelqu'un peut-il penser à des similitudes (à l'exception de la très évidente: "ce sont deux mots clés en C #")?

Answer 5

La principale différence entre foreach et using est que IEnumerable est utilisé pour énumérer un IDisposable alors qu'un <=> est utilisé pour définir une étendue en dehors de laquelle un objet sera supprimé.

Il existe une similitude entre <=> et <=>: les énumérateurs implémentent <=> et un <=> mettra implicitement l'utilisation d'un énumérateur dans un bloc <=>. Une autre façon de le dire est qu’un <=> peut être recodé en tant que bloc d’utilisation et que l’IL résultant sera identique.

Le bloc de code

var list = new List<int>() {1, 2, 3, 4, 5};
foreach(var i in list) {
    Console.WriteLine(i);
}

est effectivement identique à

var list = new List<int>() {1, 2, 3, 4, 5};
using (var enumerator = list.GetEnumerator()) {
    while (enumerator.MoveNext()) {
        Console.WriteLine(enumerator.Current);
    }
}