簡單的SQL連接類用於CRUD OPS和交易

Question

我一直想寫一個SQL連接類的小項目，該項目將使用簡單的SQL命令插入/更新/選擇/刪除OPS有時與交易，是有任何指導我可以使用？這個類可以在有或沒有交易的任何一點被實例化......

嘗試：？

public class DbConnection 

{ 
    public static string srConnectionString = "blablab"; 

public DbConnection() 
{ 

} 

public static DataSet db_Select_Query(string strQuery) 
{ 
    DataSet dataSet = new DataSet(); 

    try 
    { 
     using (SqlConnection connection = new SqlConnection(srConnectionString)) 
     { 
      connection.Open(); 
      SqlDataAdapter _SqlDataAdapter = new SqlDataAdapter(strQuery, connection); 
      DA.Fill(dataSet); 
     } 
     return dataSet; 
    } 

    catch (Exception) 
    { 
     //some error handling. 
    } 
} 

public static void db_Update_Delete_Query(string strQuery) 
{ 
    try 
    { 
     using (SqlConnection connection = new SqlConnection(srConnectionString)) 
     { 
      connection.Open(); 
      SqlCommand command = new SqlCommand(strQuery, connection); 
      command.ExecuteNonQuery(); 
     } 
    } 
    catch (Exception) 
    { 
     //some error handling. 
    } 
} 

例如我怎樣才能添加打開或只要這個類是用來關閉交易中的參數例如，我可以從類外部調用db.commit或db.rollback。

PS：嘗試了一些微觀的ORM（petapoco爲前），是有辦法用純SQL運行它們並獲得返回類型，因爲只有數據集或數據表？

問候。

編輯：

public class dbconnection : IDisposable 
{ 
    public static string strConnectionString = @"Data Source=PC137\PC137_SQL2008;Initial Catalog=BARZO;Integrated Security=True"; 

    #region IDisposable Members 

    public void Dispose() 
    { 
     GC.SuppressFinalize(this); 
    } 

    #endregion 

    private SqlTransaction transaction; 
    private SqlConnection connection; 
    private SqlCommand command = new SqlCommand(); 


    public void db_OpenConnection(bool WithTransaction) 
    { 
     connection = new SqlConnection(strConnectionString); 
     connection.Open(); 

     if (WithTransaction) 
     { 
      transaction = connection.BeginTransaction(); 
     } 
    } 


    public void db_CloseConnection() 
    { 
     connection.Close(); 
     connection.Dispose(); 
     transaction.Dispose(); 
     command.Dispose(); 
    } 


    public void db_Commit() 
    { 
     transaction.Commit(); 
    } 


    public void db_RollBack() 
    { 
     transaction.Rollback(); 
    } 


    public DataSet db_Select_Query(string strQuery) 
    { 
     var dataSet = new DataSet(); 

     try 
     { 
      SqlDataAdapter SqlDataAdapter = new SqlDataAdapter(strQuery, connection); 
      SqlDataAdapter.Fill(dataSet); 
      return dataSet; 
     } 

     catch (SqlException sqlError) 
     { 
      MessageBox.Show(sqlError,MessageBoxButtons.OK, MessageBoxIcon.Stop); 
     } 
    } 

    public bool db_Update_Delete_Query(string strQuery) 
    { 
     try 
     { 
      command = new SqlCommand(strQuery, connection); 
      command.Transaction = transaction; 
      command.ExecuteNonQuery(); 
     } 
     catch (SqlException sqlError) 
     { 
      MessageBox.Show(sqlError,MessageBoxButtons.OK, MessageBoxIcon.Stop); 
      return false; 
     } 
     return true; 
    } 
} 

Answer 1

我會使db_Update_Delete_Query()方法返回自己DbCommandToken，它包裝的SqlTransaction對象，可用於取消交易或報告命令完成。

這看起來像這樣。

public class DbConnection 
{ 
    public static DbCommandToken db_Update_Delete_Query(string strQuery) 
    { 
     try 
     { 
      using (SqlConnection connection = new SqlConnection(strConnectionString)) 
      { 
       connection.Open(); 
       var transaction = connection.BeginTransaction(); 
       SqlCommand command = new SqlCommand(strQuery, connection); 
       return new DbCommandToken(transaction, command); 
      } 
     } 
     catch (Exception) 
     { 
      //some error handling. 
     } 
    } 
} 

注意，您的命令和您的交易現在被你DbCommandToken對象，它應該實現IDisposable擁有。

如果你的命令是一個長時間運行的命令，你可能想要異步運行，也許可以用稍後的請求來取消，你可以在你的DbCommandToken上添加成功和失敗回調：沿着這些方向。

public class DbCommandToken : IDisposable 
{ 
    private readonly SqlTransaction _transaction; 
    private readonly SqlCommand _command; 

    public DbCommandToken(SqlTransaction transaction, SqlCommand command) 
    { 
     _transaction = transaction; 
     _command = command; 
    } 

    public Action Success { get; set; } 

    public Action Failure { get; set; } 

    public Task<int> Execute() 
    { 
     return Task.Factory.StartNew(() => _command.ExecuteNonQuery()) 
      .ContinueWith(t => 
       { 
        var rowsAffected = t.Result; 
        if (rowsAffected >= 0) 
        { 
         _transaction.Commit(); 
         Success(); 
        } 

        ...Handle other scenarios here... 

        return t.Result; 
       }); 
    } 

    public void Cancel() 
    { 
     _transaction.Rollback(); 
    } 

    public void Dispose() 
    { 
     _command.Dispose(); 
     _transaction.Dispose(); 
    } 
}