这种方法比较简单好用，缺点对多个方法的事务的控制不太友好，它只能写在一个方法里面。（解决方法：可以通过把当前方法的db对象作为参数传到别一个方法里面）

这种方式是本人认为最佳用法，前提你要会使用IOC技术。

1.创建一个数据访问类

    /// <summary>
    ///数据访问层
    /// </summary>
    public class DbService : IDisposable
    {
        public SqlSugarClient _db;
        public DbService()
        {
            _db = new SqlSugarClient("sever=.;sa=saxxxx");//获SqlSugarClient对象
        }
        public void Dispose()
        {
            if (_db != null)
            {
                _db.Dispose();
            }
        }
    }

2.对DbService进行注入，当return view之后便后便会自动销毁 DbService 自动调用 DbService.Dispose()

using Infrastructure.Dao;
using Infrastructure.DbModel;
using Infrastructure.Pub;
using SyntacticSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using SqlSugar;
namespace SugarSite
{
    public class BaseController : Controller
    {
        protected SqlSugarClient _db;
        protected BaseController(DbService s)
        {
            _db = s._db;
            
        }
        public ActionResult Index() {
            var list=_db.Queryable<DocContent>().ToList();
            return View();
        }
    }
}

在DbService.Dispose里面打个断点，如果运行上面代码可以执行断点，恭喜你成功了。

注意：

多层架构也是一样用法 只要DbService是通过注入使用的都会释放，例如 conntroller注入BLL,BLL注入DbService也是一样的。

参考地址：http://www.codeisbug.com/Ask/9/38

SqlSugarClient与SqlConnection是一样的性质

当前的SqlSugarClient对象下的多个操作只打开了一次数据库

不使用时需要释放数据库。

为什么EF不需要释放呢？

原因很简单 EF每一条查询都会打开和关闭数据库，增 删 改等操作会通过db.savechange打开并且关闭数据库。

缺点：循环等操作性能差

优点：不需要释放资源

SqlSugar实现EF这种自动释放

只有3.5.3支持

继承SqlSugraClient重写底层

      public class SqlSugarAutoCloseClient : SqlSugarClient
        {
            public SqlSugarAutoCloseClient(string connectionString)
                : base(connectionString)
            {

            }
            protected override void ExecLogEvent(string sql, SqlParameter[] pars, bool isStarting = true)
            {
                base.ExecLogEvent(sql, pars, isStarting);
                if (isStarting == false&&IsDr==false)
                {
                    Close();
                }
            }
            internal  void RequestParasToSqlParameters(SqlParameterCollection oldParas)
            {
                var oldParaList = oldParas.Cast<SqlParameter>().ToList();
                var paraDictionarAll = SqlSugarTool.GetParameterDictionary();
                if (paraDictionarAll != null && paraDictionarAll.Count() > 0)
                {

                    foreach (KeyValuePair<string, string> it in paraDictionarAll)
                    {

                        var par = new SqlParameter("@" + it.Key, it.Value);
                        if (!oldParaList.Any(oldPara => oldPara.ParameterName == ("@" + it.Key)))
                        {
                            oldParas.Add(par);
                        }
                    }
                }
            }
            private bool IsDr = false;
            public override SqlDataReader GetReader(string sql, params SqlParameter[] pars)
            {
                SetCurrentConnection(false);
                ExecLogEvent(sql, pars, true);
                SqlCommand sqlCommand = new SqlCommand(sql, _sqlConnection);
                sqlCommand.CommandType = this.CommandType;
                sqlCommand.CommandTimeout = this.CommandTimeOut;
                if (_tran != null)
                {
                    sqlCommand.Transaction = _tran;
                }
                if (pars != null)
                    sqlCommand.Parameters.AddRange(pars);
                if (this.IsGetPageParas)
                {
                    RequestParasToSqlParameters(sqlCommand.Parameters);
                }
                CheckConnect();
                IsDr = true;
                SqlDataReader sqlDataReader = sqlCommand.ExecuteReader(CommandBehavior.CloseConnection);//dr关闭连接对象也关闭
                if (this.IsClearParameters)
                    sqlCommand.Parameters.Clear();
                ExecLogEvent(sql, pars, false);
                IsDr = false;
                return sqlDataReader;
            }
            public override void CommitTran()
            {
                base.CommitTran();
                Close();
            }
            public override void RollbackTran()
            {
                base.RollbackTran();
                Close();
            }
            private void Close()
            {
                if (base._tran == null && _sqlConnection.State != ConnectionState.Closed)
                {
                    _sqlConnection.Close();
                }
            }
        }

下面就随便调了无需担心释放问题

for (int i = 0; i < 1000; i++)
{
                SqlSugarAutoCloseClient db = new SqlSugarAutoCloseClient(SugarDao.ConnectionString);
                var x = db.Queryable<Student>().ToList();
                db.Delete<Student>(it=>it.id=100);
}

for (int i = 0; i < 1000; i++)
{
                SqlSugarAutoCloseClient db = new SqlSugarAutoCloseClient(SugarDao.ConnectionString);
                db.BeginTran();
                var x = db.GetDataTable("select 1");
                db.CommitTran();
}