Formateo/sangría para el uso de declaraciones (C#)

Question

Cuando se trata de using declaraciones en C# (que no debe confundirse con usingdirectivas que importar los espacios de nombres), Visual Studio no código de una sola línea no guión que sigue, si no hay apoyos estan empleados. Esto es típico de las declaraciones de "anidamiento" que se muestran en this SO question.

me resulta confuso que las declaraciones posteriores tras using no son sangría, a diferencia del formato de una instrucción if:

// non-indented using statement 
using (var myResource = new SomeIDisposableResource()) 
myResource.Indent(false); 

// indented if statement 
if (something == true) 
    IndentMe(); 

¿Hay alguna razón no para sangrar, o es sólo preferencia?

// indented using statement, but not the default VS formatting 
using (var myResource = new SomeIDisposableResource()) 
    myResource.Indent(); 

EDIT:

La prueba adicional revela que era incorrecta sobre algunos de los comportamientos formato VS. Si se escribe una instrucción using:

using (var myResource = SomeIDisposableResource()) 

... y pulsa enter, el cursor se alineará con using. Si la siguiente línea también es una instrucción de uso, continuará alineándose. Si no lo es, VS lo sangrará al finalizar. Por lo tanto, mi pregunta original está algo invalidada, porque mi primer ejemplo no se puede lograr a menos que anule el formato predeterminado o use un IDE que no lo haga.

Aún así, vale la pena saber que múltiples instrucciones using se tratan mejor como un solo bloque porque técnicamente lo son. La falta de sangría solo se aplica cuando las declaraciones son secuencial using declaraciones sin llaves; y a medida que uno se acostumbra, dejan de parecer tan inusual.

Como siempre, gracias a todos los que respondieron por su conocimiento y experiencia incluso en estos pequeños detalles de programación.

Answer 1

Como han dicho otros, siempre use llaves. Sin embargo, hay una modismo, que algo va en contra de este y utiliza el "no-sangría":

using (Resource1 res1 = new Resource1()) 
using (Resource2 res2 = new Resource2()) 
using (Resource3 res3 = new Resource3()) 
{ 
    // Do stuff with res1, res2 and res3 
} 

Pero yo siempre utilizar llaves para el bloque más interno :)

Answer 2

Es su preferencia. Siempre sangro y coloco los elementos necesarios entre paréntesis

using(var t = new t()) 
{ 
    t.Foo(); 
} 

Answer 3

Solución fácil: utilice siempre bloques explícitos, incluso para líneas individuales. ¡Visual Studio sangrará correctamente y, como bonificación, su código será más fácil de mantener!

Answer 4

Al igual que mi C El instructor me dijo hace más de 10 años: Siempre, siempre, siempre use los frenos. Las probabilidades son buenas de que alguien venga (posiblemente incluso usted) y arroje otra línea de código, y luego se pregunte por qué no se está comportando correctamente.

Answer 5

Me gusta ser votado negativamente cuando me equivoco, así que voy a hacer una respuesta a esto ...

Así es como me gustaría darle formato:

using (Resource1 res1 = new Resource1()) 
using (Resource2 res2 = new Resource2()) 
using (Resource3 res3 = new Resource3()) 
    DoStuffWithResources(res1, res2, res3); 

Si tuviera que sustituir DoStuffWithResources con varias instrucciones, me gustaría hacer aparatos de uso. Sin embargo, mi editor me impide tener que hacer el siguiente error:

using (Resource1 res1 = new Resource1()) 
using (Resource2 res2 = new Resource2()) 
using (Resource3 res3 = new Resource3()) 
    DoStuffWithResources(res1, res2, res3); 
    DoOtherStuffWithResources(res1, res2, res3); 

Cuando trato de entrar en lo anterior, inmediatamente me sale:

using (Resource1 res1 = new Resource1()) 
using (Resource2 res2 = new Resource2()) 
using (Resource3 res3 = new Resource3()) 
    DoStuffWithResources(res1, res2, res3); 
DoOtherStuffWithResources(res1, res2, res3); 

Pro consejo: Un downvote no es un argumento en contra, por lo si no tienes uno, no deberías votar.