C#中事务的问题（高手们来解答啊！）

[cainiao116]

现在项目中出现这样一个问题，数据库就一个。以前代码中就用的TransactionScope，这样事务级别好像就提升到了分布式事务，必须设置MSDTC。
我们这种数据库只有一个的情况完全可以用本地事务完成，所以想改变一下现有的代码。
如果有sqlTransaction肯定是可以实现，但是太麻烦了，操作量太大，每个COMMAND都需要指定他的Transction。
有没有什么方法使用TransactionScope或CommittableTransaction但是事务级别还是本地事务的吗？？？这样改动就会小很多，而且也不用设置MSDTC了。
现在的代码实现一般是：

 using (System.Transactions.TransactionScopetrans trans= new System.Transactions.TransactionScope())
        {
            try
            {
               函数1；
                 函数2；
                 ……
                trans.Complete();
            }
            catch ()
            {
                trans.Dispose();
            }
        }

希望高手们解答。。。 分不够再加

[heping173]

http://topic.csdn.net/u/20080802/18/4d954442-8606-485c-84ce-444e5eeb6c5a.html

[lihongdian]

你仔细看看COM+和Enterpirse

[include_me]

似乎TransactionScope不一定会将事务级别提升到分布式事务吧..

[wwd252]

mark

[foxsorange]

给你一段代码参考：
public bool ExecuteTransaction(string SQL)
{
this.Open();
System.Data.SqlClient.SqlTransaction action=this.SqlCnn.BeginTransaction();
System.Data.SqlClient.SqlCommand cmd=this.SqlCnn.CreateCommand();
cmd.Connection=this.SqlCnn;
cmd.Transaction=action;
try
{
cmd.CommandText=SQL;
cmd.ExecuteNonQuery();
action.Commit();
this.Close();
return true;
}
catch(Exception )
{
try
{
action.Rollback();
this.Close();
return false;
}
catch(SqlException)
{
this.Close();
return false;
}
}
}

[yyq136]

关注

[wfcfan]

public sealed class DataAccess
    {
        //private static string _appConnectionString = null;

        private static string AppConnectionString
        {
            get
            {
                return ConfigurationManager.ConnectionStrings["ConnectionSQLSttring"].ConnectionString;
            }
        }

        public DataAccess() : this(false) { }
        public DataAccess(bool useTransaction)
        {
            _useTransaction = useTransaction;
            init();
        }

        private SqlTransaction _t = null;
        private SqlConnection _cnn = null;
        private bool _disposed = false;
        private bool _useTransaction = false;
        private void init()
        {
            SqlConnection cnn = new SqlConnection(DataAccess.AppConnectionString);
            cnn.Open();
            _cnn = cnn;
            if (_useTransaction)
                _t = cnn.BeginTransaction(IsolationLevel.Serializable);
        }

        public void Commit()
        {
            //if (_disposed)
            //    throw new ObjectDisposedException(this.ToString());

            if (_useTransaction)
            {
                _t.Commit();
                _t = null;
            }

            _cnn.Close();
            _cnn = null;
            this.Dispose();
        }

        private void Dispose()
        {
            if (!_disposed)
            {
                if (_cnn != null)
                {
                    if (_t != null)
                    {
                        _t.Rollback();
                        _t = null;
                    }

                    _cnn.Close();
                    _cnn = null;
                }
                _disposed = true;
                GC.SuppressFinalize(this);
            }
        }

        #region GetTable
        //[DebuggerStepThrough()]
        public DataTable GetTable(string sql)
        {
            SqlCommand cmd = new SqlCommand(sql);
            return GetTable(cmd, "");
        }
        public DataTable GetTable(string sql, string p_tblName)
        {
            SqlCommand cmd = new SqlCommand(sql);
            return GetTable(cmd, p_tblName);
        }
        //[DebuggerStepThrough()]
        public DataTable GetTable(SqlCommand cmd, string p_tblName)
        {
            //if (_disposed)
            //    throw new ObjectDisposedException(this.ToString());

            //if (cmd.Connection != null)
            //    throw new HasConnectionException();

            DataTable dt = new DataTable();
            if (p_tblName != null)
                dt.TableName = p_tblName;
            SqlDataAdapter da = null;
            try
            {
                cmd.Connection = _cnn;
                cmd.Transaction = _t;
                da = new SqlDataAdapter(cmd);
                da.Fill(dt);
            }
            catch
            {
                throw;
            }
            finally
            {
                if (da != null)
                    da.Dispose();
                cmd.Connection = null;
                cmd.Transaction = null;
            }
            return dt;
        }
        #endregion

        #region ExecuteCmd
        //[DebuggerStepThrough()]
        public int ExecuteCmd(string sql)
        {
            SqlCommand cmd = new SqlCommand(sql);
            return ExecuteCmd(cmd);
        }

        //[DebuggerStepThrough()]
        public int ExecuteCmd(SqlCommand cmd)
        {
            //if (_disposed)
            //    throw new ObjectDisposedException(this.ToString());

            //if (cmd.Connection != null)
            //    throw new HasConnectionException();

            try
            {
                cmd.Connection = _cnn;
                cmd.Transaction = _t;
                return cmd.ExecuteNonQuery();
            }
            catch
            {
                throw;
            }
            finally
            {
                cmd.Connection = null;
                cmd.Transaction = null;
            }
        }
        #endregion

        #region ExecuteScalar
        // [DebuggerStepThrough()]
        public object ExecuteScalar(string sql)
        {
            SqlCommand cmd = new SqlCommand(sql);
            return ExecuteScalar(cmd);
        }

        // [DebuggerStepThrough()]
        public object ExecuteScalar(SqlCommand cmd)
        {
            //if (_disposed)
            //    throw new ObjectDisposedException(this.ToString());

            //if (cmd.Connection != null)
            //    throw new HasConnectionException();

            try
            {
                cmd.Connection = _cnn;
                cmd.Transaction = _t;
                return cmd.ExecuteScalar();
            }
            catch
            {
                throw;
            }
            finally
            {
                cmd.Connection = null;
                cmd.Transaction = null;
            }
        }
        #endregion

        #region GetDataReader
        // [DebuggerStepThrough()]
        public SqlDataReader GetDataReader(string sql)
        {
            SqlCommand cmd = new SqlCommand(sql);
            return GetDataReader(cmd);
        }

        // [DebuggerStepThrough()]
        public SqlDataReader GetDataReader(SqlCommand cmd)
        {
            //if (_disposed)
            //    throw new ObjectDisposedException(this.ToString());

            //if (cmd.Connection != null)
            //    throw new HasConnectionException();

            try
            {
                cmd.Connection = _cnn;
                cmd.Transaction = _t;
                return cmd.ExecuteReader();
            }
            catch
            {
                throw;
            }
            finally
            {
                ;
            }
        }
        #endregion      
    }

[wfcfan]

DataAccess da = new DataAccess();
string s = da.ExecuteScalar("select getdate()");
da.Commit();
Response.Writer(s);

[cainiao116]

。。。。。用transactionScope确实不一定会提升事务级别到分布式事务，但是MSDTC是肯定会要用的。 如果不设置还是会提示"事务已被隐式或显式提交，或已终止"。
至于5楼的代码，我也知道，我想您是没看清我的意思，现在的情况是想怎么最方便的实现这种改动。如果你这样必须给每个COMMAND都加Transaction属性。

也许我还没太表达清楚。
其实我就是想要有一种方法可以实现代码块的事务（如只要写一个using……就能让代码中所有的操作及里面函数的操作都归到一个事务中去，用transctionScope的话就会提升到分布式事务，这不是我想要的），而不用每个地方的command的修改。

至于7楼，。。额，，代码改动更大了~~

[tootto]

TransactionScope是方法级的transaction，而sqlTransaction是数据库级别的transaction。

如果用TransactionScope则一定要配置DTC,除非client/server都在一台机器上。

研究一下SOA, 用一个service类来执行所其它的类的内部方法。这样一但transaction逻辑改变，只需修改这个service类即可。