conversion utilizzando vari tipi in una istruzione using(C#)




c# value types (4)

Poiché 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.


Answer #1

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


Answer #2

Non c'è una ragione tecnica particolarmente buona; avremmo potuto trovare una sintassi 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.


Answer #3

Il mio modo personale di utilizzare 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 facile da programmare 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.


Answer #4

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.





using