Aliénation en C # en utilisant des blocs

Question

Je suis vraiment pris la peine d'avoir à imbriquer des blocs de using en C #. Ce n'est pas élégant et il prend beaucoup d'espace. Dans certains cas, il semble inévitable parce que je dois déclarer des variables de différents types de données, mais il semble que le cas de type unique devrait être possible de simplifier. Ce que je veux dire par « le cas de type unique » est lorsque plusieurs variables du même type sont déclarées en série. Voici un exemple de ce dont je parle:

class Program
{
    static void Main(string[] args)
    {
        using (A a = new A("a"), b = new A("b"))
        {
        }
    }

    class A : IDisposable
    {
        string n = null;
        public A(string name)
        {
            n = name;
            Console.WriteLine(String.Format("Creating {0}", n));
        }

        public void Dispose()
        {
            Console.WriteLine(String.Format("Disposing {0}", n));
        }
    }
}

La façon dont je veux que ce travail est que a construit avant b, et que b est disposé avant a. Malheureusement, il ne semble pas y avoir de direction dans la spécification C # à la façon dont il devrait effectivement se produire. Il semble que Microsoft de C # de compilateur traite comme ceci, comme cela est le résultat de l'exécution du programme ci-dessus:

Creating a
Creating b
Disposing b
Disposing a

Cependant, je n'ai aucun moyen de faire en sorte que ce comportement est déterministe. Quelqu'un peut-il confirmer ou réfuter l'idée que cette séquence est déterministe? Les références seraient grandes. Et évidemment, si elle est sujette à la rupture (en situation irrégulière, etc.), il est probablement pas utile, mais c'est une bonne chose à savoir.

Il y a déjà une question semblable sur élimination déterministe qui parle de cas multiples de type, et je comprends qu'il n'y a pas de solution réelle là-bas à part des astuces de syntaxe intelligent. La plupart des réponses y manquent le point, de toute façon. Ma question est à peu près le cas de type simple et si cette disposition est déterministe et fiable ou non. Merci.

Answer 1

De la C # spec:

« Une déclaration de using de la forme using (ResourceType r1 = e1, r2 = e2, ..., rN = eN) est précisément équivalente à une séquence d'instructions de using imbriquées: »

using (ResourceType r1 = e1)
   using (ResourceType r2 = e2)
      ...
         using (ResourceType rN = eN)
            statement

Il semble donc juste de dire que cela est tout à fait coulé dans le béton.

Answer 2

Y at-il des raisons pour lesquelles vous ne pouvez pas utiliser l'astuce de multiples à l'aide? C'est entièrement déterministe, et résout votre problème

using (A a = new A("a"))
using (A b = new A("b")) {
    // ....
}