简单的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(); 
    } 
}