请大家评审一下这个事务控制设计方案！

Question

即将要开发一个采用三层架构的系统，系统的特点是并发访问量很大，事务使用频繁。在实现事务控制的同时也要兼顾性能，经过一番学习后作出了下面的设计，由于小弟接触.NET不久，非常欠缺经验，系统又很关键，请大家看看有什么不妥和需要改进的地方，多多指点。这个设计中没有考虑到可扩展性，设计的重点是要在现有环境下保证性能。持久化上下文类，事务主要由它控制：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Transactions;
using System.Runtime.Serialization;
using SD.Utility;namespace SD.DAL
{
    /// <summary>
    /// 持久化上下文。
    /// </summary>
    public class PersistenceContext : IDisposable
    {
        private SqlConnection connection;
        private TransactionScope transactionScope;        /// <summary>
        /// 默认事务超时时间：90秒。
        /// </summary>
        public static readonly TimeSpan DEFAULT_TRANSCATION_TIMEOUT = TimeSpan.FromSeconds(90);        /// <summary>
        /// 默认事务隔离级别：Read Committed。
        /// </summary>
        public const IsolationLevel DEFAULT_ISOLATION_LEVEL = IsolationLevel.ReadCommitted;        /// <summary>
        /// 私有构造方法。需使用本类提供的静态Create方法创建对象。
        /// </summary>
        private PersistenceContext() { }        /// <summary>
        /// 创建一个默认的持久化上下文对象，事务隔离级别为Read Committed，事务超时时间为90秒。
        /// </summary>
        /// <returns>持久化上下文</returns>
        public static PersistenceContext CreateInstance()
        {
            return CreateInstance(DEFAULT_ISOLATION_LEVEL);
        }        /// <summary>
        /// 创建一个具有指定事务隔离级别的持久化上下文对象，事务超时时间为90秒。
        /// </summary>
        /// <param name="isolationLevel">事务隔离级别</param>
        /// <returns>持久化上下文</returns>
        public static PersistenceContext CreateInstance(IsolationLevel isolationLevel)
        {
            return CreateInstance(isolationLevel, DEFAULT_TRANSCATION_TIMEOUT);
        }        /// <summary>
        /// 创建一个具有指定事务隔离级别和超时时间的持久化上下文对象。
        /// </summary>
        /// <param name="isolationLevel">事务隔离级别</param>
        /// <param name="transactionTimeout">事务超时时间</param>
        /// <returns>持久化上下文</returns>
        public static PersistenceContext CreateInstance(IsolationLevel isolationLevel, TimeSpan transactionTimeout)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = isolationLevel;
            options.Timeout = transactionTimeout;            TransactionScope transactionScope = new TransactionScope(TransactionScopeOption.Required, options);            PersistenceContext persistenceContext = new PersistenceContext();
            persistenceContext.transactionScope = transactionScope;
            return persistenceContext;
        }        /// <summary>
        /// 创建一个自动提交事务的持久化上下文。
        /// </summary>
        /// <returns>持久化上下文</returns>
        public static PersistenceContext CreateAutocommitInstance()
        {
            return new PersistenceContext();
        }
        /// <summary>
        /// 获得当前持久化上下文中已打开的SQL Server数据库连接， 该对象仅在第一次被访问时创建。
        /// </summary>
        public SqlConnection Connection
        {
            get
            {
                if (connection == null)
                {
                    connection = DBHelper.GetConnection();
                    connection.Open();
                }                return connection;
            }
        }        /// <summary>
        /// 提交事务。
        /// </summary>
        public void Commit()
        {
            if (transactionScope != null)
            {
                transactionScope.Complete();
            }
        }        /// <summary>
        /// 清除非托管资源：
        ///     1. 释放数据库连接；
        ///     2. 关闭事务。
        /// </summary>
        public void Dispose()
        {
            if (connection != null)
            {
                connection.Dispose();
                connection = null;
            }            if (transactionScope != null)
            {
                transactionScope.Dispose();
                transactionScope = null;
            }
        }    }
}
数据存取基类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;namespace SD.DAL
{
    /// <summary>
    /// 抽象DAO类。
    /// </summary>
    public abstract class BaseDAO
    {
        private PersistenceContext persistenceContext;        /// <summary>
        /// 创建一个使用指定持久化上下文的DAO类。
        /// </summary>
        /// <param name="persistenceContext">持久化上下文</param>
        protected BaseDAO(PersistenceContext persistenceContext)
        {
            this.persistenceContext = persistenceContext;
        }        /// <summary>
        /// 获取当前已打开的数据库连接。
        /// </summary>
        public SqlConnection Connection
        {
            get
            {
                return persistenceContext.Connection;
            }
        }    }
}
数据存取类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using SD.Utility;
using SD.Model;namespace SD.DAL
{
    public class PermissionDAO : BaseDAO
    {        private const string SQL_INSERT_PERMISSION = "INSERT INTO Permission(Name) VALUES(@Name)";        public PermissionDAO(PersistenceContext persistenceContext)
            : base(persistenceContext) { }        public bool insert(Permission permission)
        {
            using (SqlCommand cmd = new SqlCommand(SQL_INSERT_PERMISSION, Connection))
            {
                SqlParameter nameParam = new SqlParameter("@Name", SqlDbType.NVarChar);
                nameParam.Value = permission.Name;                cmd.Parameters.Add(nameParam);                int count = cmd.ExecuteNonQuery();
                return count > 0;
            }
        }
    }
}
测试方法：
        [TestMethod]
        public void TestTransaction()
        {
            using (PersistenceContext context = PersistenceContext.CreateInstance())
            {
                PermissionDAO dao = new PermissionDAO(context);                Permission p1 = new Permission();
                p1.Name = "1";                Permission p2 = new Permission();
                p2.Name = "2";                dao.insert(p1);
                // 若出现异常，整个事务就会回滚
                dao.insert(p2);                context.Commit(); // 提交事务
            }
        }        [TestMethod]
        public void TestAutocommitTransaction()
        {
            using (PersistenceContext context = PersistenceContext.CreateAutocommitInstance())
            {
                PermissionDAO dao = new PermissionDAO(context);                Permission p1 = new Permission();
                p1.Name = "好";                Permission p2 = new Permission();
                p2.Name = "人";                dao.insert(p1);
                dao.insert(p2);
            }
        }

Answer 1

DAO类每一次去拿新的数据库连接也是可以的，但是这样会升级为分布式事务，我担心会影响性能，所以在每一个持久化上下文的多次数据库操作中只使用一个Connection对象。