usando vari tipi in una istruzione using (C #)

Dato che l’istruzione using C # è solo uno zucchero sintattico per try / finally {dispose} perché accetta più oggetti SOLO SE ESISTE DELLO STESSO TIPO?

Non capisco perché tutto ciò che devono essere è IDisposable. Se tutti implementano IDisposable, dovrebbe andare bene, ma non lo è.

Nello specifico sono abituato a scrivere

using (var cmd = new SqlCommand()) { using (cmd.Connection) { // code } } 

che compongo in:

 using (var cmd = new SqlCommand()) using (cmd.Connection) { // code } 

e mi piacerebbe anche compattare in:

 using(var cmd = new SqlCommand(), var con = cmd.Connection) { // code } 

ma non posso. Potrei probabilmente, qualcuno direbbe, scrivere:

 using((var cmd = new SqlCommand()).Connection) { // code } 

poiché tutto ciò di cui ho bisogno è la connessione e non il comando, ma questo è oltre il punto.

Puoi farlo anche se:

 using (IDisposable cmd = new SqlCommand(), con = (cmd as SqlCommand).Connection) { var command = (cmd as SqlCommand); var connection = (con as SqlConnection); //code } 

Forse sarebbe soddisfacente per te.

Non c’è una ragione tecnica particolarmente buona; avremmo potuto trovare una syntax che consentisse più dichiarazioni di tipi non omogenei. Dato che non l’abbiamo fatto, e c’è già un meccanismo perfettamente buono, chiaro, comprensibile e abbastanza conciso per dichiarare nidificati usando blocchi di tipi diversi, è improbabile che aggiungiamo un nuovo zucchero sintattico solo per risparmiare alcune sequenze di tasti.

Altre dichiarazioni variabili in C # consentono solo di dichiarare più variabili dello stesso tipo nella stessa istruzione; Non vedo perché using intestazioni dovrebbe essere diverso.

Il mio modo personale di usare questo potrebbe adattarsi al disegno di legge:

 private const string SQL_CONNECTION = "Your Connection String Here"; private void Test(string sqlCmd) { using (var cmd = new SqlCommand(sqlCmd, new SqlConnection(SQL_CONNECTION))) { cmd.Connection.Open(); cmd.ExecuteNonQuery(); cmd.Connection.Close(); // Close() is not really necessary. // Dispose will Close the connection. } } 

No, non ci sono due istanze della clausola using in una riga, ma è così compatto come si sta cercando di ottenere nel proprio esempio.

Inoltre, puoi renderlo ancora più compatto e programmabile, trasformando la tua stringa di connessione in una proprietà privata:

 private SqlConnection OpenConnection { get { var con = new SqlConnection(SQL_CONNECTION); con.Open(); return con; } } 

Ora, quel primo bit di codice sopra in Test() potrebbe essere abbreviato come segue:

 private void Test2(string sqlCmd) { using (var cmd = new SqlCommand(sqlCmd, OpenConnection)) { cmd.ExecuteNonQuery(); } } 

Questo rende la codifica molto carina.