przy użyciu różnych typów w instrukcji using (C#)

Question

Ponieważ instrukcja C# używająca jest tylko syntaktycznym cukrem dla try/finally {dispose} dlaczego akceptuje wiele obiektów TYLKO JEŚLI JEST TO TYM SAMEGO TYPU?

Nie rozumiem tego, ponieważ wszystko, co musi być, jest IDisposable. Jeśli wszystkie implementują IDisposable, powinno być dobrze, ale tak nie jest.

Konkretnie jestem przyzwyczajony do pisania

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

które kompaktowy do:

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

i chciałbym kompaktowy ponadto do:

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

ale nie mogę . Mógłbym prawdopodobnie, niektórzy twierdzą, napisać:

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

ponieważ wszystko muszę wyrzucać jest związek, a nie polecenie, ale to prócz tego punktu.

Answer 1

Można to zrobić choć:

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

Być może byłoby satysfakcjonujące dla Ciebie.

Answer 2

Inne deklaracje zmiennych w języku C# umożliwiają tylko zadeklarowanie wielu zmiennych tego samego typu w tej samej instrukcji; Nie rozumiem, dlaczego nagłówki powinny być inne.

Answer 3

Nie ma szczególnie dobrego technicznego uzasadnienia; moglibyśmy wymyślić składnię, która dopuszczała wiele deklaracji typów niejednorodnych. Biorąc pod uwagę, że tego nie zrobiliśmy i istnieje już doskonale dobry, jasny, zrozumiały i dość zwięzły mechanizm deklarowania zagnieżdżenia przy użyciu bloków różnych typów, prawdopodobnie nie będziemy dodawać nowego cukru syntaktycznego tylko po to, aby zapisać kilka naciśnięć klawiszy.

Answer 4

Mój osobisty sposób korzystania z tego może pasowały:

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. 
    } 
} 

Nie, to nie dwa przypadki klauzuli w jednej linii using, ale to jest tak zwarta, jak starają się dostać w swoje przykład.

Co więcej, można zrobić to jeszcze bardziej kompaktowy i przyjazny obracając swój ciąg połączenia do prywatnej posesji programista:

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

teraz, że pierwszy bit kodu powyżej w Test() może być skrócony do następujących :

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

To sprawia, że ​​kodowanie jest bardzo przyjemne.