Refactor Code in die Verwendung der Anweisung

Question

Ich habe eine Dal-Ebene mit vielen Methoden, alle rufen gespeicherte Prozeduren, einige Rücksprunglisten (so mit einer Verwendung von SqlDataReader), andere nur einen bestimmten Wert.

Ich habe eine Hilfsmethode, die die SqlCommand erstellt:

protected SqlCommand CreateSprocCommand(string name, bool includeReturn, SqlDbType returnType) 
    { 
     SqlConnection con = new SqlConnection(this.ConnectionString); 
     SqlCommand com = new SqlCommand(name, con); 
     com.CommandType = System.Data.CommandType.StoredProcedure; 

     if (includeReturn) 
      com.Parameters.Add("ReturnValue", returnType).Direction = ParameterDirection.ReturnValue; 

     return com; 
    } 

Jetzt ist mein Durchschnitt (übermäßig vereinfacht) Methode Körper wie folgt aussehen:

SqlCommand cmd = CreateSprocCommand("SomeSprocName"); //an override of the above mentioned method 
try { 
    cmd.Connection.Open(); 
    using (var reader = cmd.ExecuteReader()) { 
     //some code looping over the recors 
    } 
    //some more code to return whatever needs to be returned 
} 
finally { 
    cmd.Connection.Dispose(); 
} 

Gibt es eine Möglichkeit, um diese zu Refactoring, so dass Ich werde meine Hilfsfunktion nicht verlieren (es macht ziemlich viel sonst repetitive Arbeit), und kann doch using verwenden?

Answer 1

Eine Möglichkeit ist es von zu ändern ein Befehl an Rückkehr einen Delegierten nehmen, die den Befehl verwendet:

protected void ExecuteSproc(string name, 
          SqlDbType? returnType, 
          Action<SqlCommand> action) 
{ 
    using (SqlConnection con = new SqlConnection(this.ConnectionString)) 
    using (SqlCommand com = new SqlCommand(name, con)) 
    { 
     con.Open(); 
     com.CommandType = System.Data.CommandType.StoredProcedure; 

     if (returnType != null) 
     { 
      com.Parameters.Add("ReturnValue", returnType.Value).Direction = 
       ParameterDirection.ReturnValue; 
     } 
     action(com); 
    } 
} 

(Beachten Sie, dass ich den includeReturn Parameter haben auch und entfernt gemacht returnType stattdessen Nullwert übergeben null für "kein Rückgabewert".)

Sie würden dies mit einem Lambda-Ausdruck (oder verwenden anonyme Methode):

ExecuteSproc("SomeName", SqlDbType.DateTime, cmd => 
{ 
    // Do what you want with the command (cmd) here 
}); 

diese Weise die Entsorgung in der gleichen Stelle wie die Schöpfung, und der Anrufer braucht nur nicht darum zu kümmern. Ich werde ein Fan von diesem Muster - es ist jetzt viel sauberer, wenn wir Lambda-Ausdrücke haben.

Answer 2

Wie wäre:

using (SqlCommand cmd = CreateSprocCommand("whatever")) 
{ 
    cmd.Connection.Open(); 
    using (var reader = cmd.ExecuteReader()) 
    { 
    //blabla 
    } 
} 

Answer 3

Sie können Nest mit Aussagen:

using (SqlCommand cmd = CreateSprocCommand("...")) 
{ 
    using (var connection = cmd.Connection) 
    { 
    connection.Open(); 
    using (var reader = cmd.ExecuteReader()) 
    { 
     ... 
    } 
    ... 
    } 
} 

Answer 4

Ist das, was Sie meinen?

using (SqlCommand cmd = CreateSprocCommand("SomeSprocName")) 
{ 
    cmd.Connection.Open(); 
    using (var reader = cmd.ExecuteReader()) 
    { 
     //some code looping over the recors 
    } 
} 

Answer 5

Sie können dies tun:

protected static SqlCommand CreateSprocCommand(SqlConnection con, string name, bool includeReturn, SqlDbType returnType) 
{ 
    SqlCommand com = new SqlCommand(name, con); 
    com.CommandType = System.Data.CommandType.StoredProcedure; 

    if (includeReturn) 
     com.Parameters.Add("ReturnValue", returnType).Direction = ParameterDirection.ReturnValue; 

    return com; 
} 

und es so nennen:

using (SqlConnection con = new SqlConnection(this.ConnectionString)) 
using (SqlCommand cmd = CreateSprocCommand(con, "SomeSprocName", true, SqlDbType.Int) 
{ 
    cmd.Connection.Open(); 
    using (var reader = cmd.ExecuteReader()) 
    { 
     //some code looping over the recors 
    } 
    //some more code to return whatever needs to be returned 
}