Formattazione/rientro per l'utilizzo di dichiarazioni (C#)

Question

Quando si tratta di using dichiarazioni in C# (da non confondere con usingdirettive che importare gli spazi dei nomi), Visual Studio non trattino singolo codice-line che segue, se non parentesi graffe sono impiegati. Questo è tipico di "annidamento" usando le istruzioni come mostrato in this SO question.

trovo confuso che le successive dichiarazioni dopo using non sono rientrati, a differenza della formattazione di un if dichiarazione:

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

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

C'è qualche motivo non per il rientro, o è solo la preferenza?

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

EDIT:

Ulteriori test rivela che ero errato su alcuni dei comportamenti formattazione VS. Se si digita una dichiarazione utilizzando:

using (var myResource = SomeIDisposableResource()) 

... e premere Invio, il cursore si allineerà con using. Se la riga successiva è anche un'istruzione using, continuerà ad allinearsi. Se non lo è, VS la indenterà al completamento. Quindi la mia domanda originale è in qualche modo invalidata, perché il mio primo esempio non è realmente realizzabile a meno che non si sostituisca la formattazione predefinita o si usi un IDE che non lo fa.

Tuttavia, vale la pena sapere che più istruzioni using vengono trattate come un blocco singolo perché tecnicamente lo sono. La mancanza di indentazione si applica solo quando le istruzioni sono istruzioni sequenziali using senza parentesi graffe; e come ci si abitua, smettono di sembrare così insoliti.

Come sempre grazie a tutti coloro che hanno risposto per l'intuizione e l'esperienza anche in questi piccoli dettagli di programmazione.

Answer 1

Come altri hanno già detto, utilizzare sempre le parentesi graffe. Tuttavia, c'è un linguaggio che va un po 'contro questa e utilizza il "non rientro":

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

Ma ho sempre utilizzare le parentesi per il blocco più interno :)

Answer 2

È preferibile. Rientro sempre tra parentesi e inserire gli elementi necessari

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

Answer 3

Facile da risolvere: utilizzare sempre blocchi espliciti, anche per linee singole. Visual Studio quindi indenterà correttamente, e come bonus il tuo codice sarà più manutenibile!

Answer 4

Come il mio C l'istruttore mi ha detto più di 10 anni fa: sempre, sempre, usa sempre le parentesi graffe. Le probabilità sono buone, qualcuno arriverà (forse anche voi) e introdurrà un'altra riga di codice, quindi si chiederà perché non si comporta in modo corretto.

Answer 5

Mi piace essere downvoted quando ho torto, quindi ho intenzione di fare una risposta da questo ...

Ecco come vorrei formattarlo:

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

Se dovessi sostituire DoStuffWithResources con più istruzioni, mi farebbe uso parentesi graffe. Tuttavia, il mio editore mi impedisce di mai fare il seguente errore:

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

Quando provo ad entrare quanto sopra, ho subito capito:

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

Pro punta: un downvote non è un argomento contrario, così se non ne hai uno, non dovresti votare.