[SQL] 단정를 사용하는 경우 연결을 닫기

단정를 사용하는 경우 연결을 닫기

쿼리하면 Close 메서드를 호출하거나 문을 사용하여 내 연결을 넣어 명시 적으로 실행이 밀접한 관계하는 것이 필요하다? 겠습니까 연결 재사용에 연결 개방 리드를 떠나 미래의 쿼리에 대한 SQL 성능을 향상?

해결법

1. ==============================

   1.난 당신이 말끔의 최신 버전을 사용하고 있다고 가정하고있다.

   난 당신이 말끔의 최신 버전을 사용하고 있다고 가정하고있다.

   말끔으로 연결을 관리하는 방법에는 두 가지가 있습니다 :

   다음은 여기에서 인용 한 것입니다 :

   당연히, 당신은 하나의 연결에서 여러 쿼리를 호출 할 수 있습니다. 그러나, 연결은 (확대 ()를 폐기 () 메소드를 호출하거나 블록을 이용하여 그것을 둘러싸) 리소스 누출을 피하기 위해 폐쇄되어야한다. 연결을 닫으면 연결 풀에 반환합니다. 연결 풀의 참여는 새로운 연결 비용을 통해 성능을 향상시킵니다.

   단지 연결을 처리 할뿐만 아니라, 당신이 아니라 트랜잭션을 관리의 UnitOfWork를 구현하는 것이 좋습니다. GitHub의에이 우수한 샘플을 참조하십시오.

   소스 코드를 따라하면 도움이 될 수 있습니다. 이는 내 요구를 위해 작성합니다; 그래서 그대로 당신을 위해 작동하지 않을 수 있습니다.

   public sealed class DalSession : IDisposable
   {
       public DalSession()
       {
           _connection = new OleDbConnection(DalCommon.ConnectionString);
           _connection.Open();
           _unitOfWork = new UnitOfWork(_connection);
       }
   
       IDbConnection _connection = null;
       UnitOfWork _unitOfWork = null;
   
       public UnitOfWork UnitOfWork
       {
           get { return _unitOfWork; }
       }
   
       public void Dispose()
       {
           _unitOfWork.Dispose();
           _connection.Dispose();
       }
   }
   
   public sealed class UnitOfWork : IUnitOfWork
   {
       internal UnitOfWork(IDbConnection connection)
       {
           _id = Guid.NewGuid();
           _connection = connection;
       }
   
       IDbConnection _connection = null;
       IDbTransaction _transaction = null;
       Guid _id = Guid.Empty;
   
       IDbConnection IUnitOfWork.Connection
       {
           get { return _connection; }
       }
       IDbTransaction IUnitOfWork.Transaction
       {
           get { return _transaction; }
       }
       Guid IUnitOfWork.Id
       {
           get { return _id; }
       }
   
       public void Begin()
       {
           _transaction = _connection.BeginTransaction();
       }
   
       public void Commit()
       {
           _transaction.Commit();
           Dispose();
       }
   
       public void Rollback()
       {
           _transaction.Rollback();
           Dispose();
       }
   
       public void Dispose()
       {
           if(_transaction != null)
               _transaction.Dispose();
           _transaction = null;
       }
   }
   
   interface IUnitOfWork : IDisposable
   {
       Guid Id { get; }
       IDbConnection Connection { get; }
       IDbTransaction Transaction { get; }
       void Begin();
       void Commit();
       void Rollback();
   }
   

   지금, 당신의 저장소는 어떤 식 으로든이의 UnitOfWork를 받아 들여야한다. 나는 생성자와 의존성 삽입 (Dependency Injection)을 선택합니다.

   public sealed class MyRepository
   {
       public MyRepository(IUnitOfWork unitOfWork) 
       {
           this.unitOfWork = unitOfWork;
       }
   
       IUnitOfWork unitOfWork = null;
   
       //You also need to handle other parameters like 'sql', 'param' ect. This is out of scope of this answer.
       public MyPoco Get()
       {
           return unitOfWork.Connection.Query(sql, param, unitOfWork.Transaction, .......);
       }
   
       public void Insert(MyPoco poco)
       {
           return unitOfWork.Connection.Execute(sql, param, unitOfWork.Transaction, .........);
       }
   }
   

   그리고 당신은 다음과 같이 호출 :

   트랜잭션 :

   using(DalSession dalSession = new DalSession())
   {
       UnitOfWork unitOfWork = dalSession.UnitOfWork;
       unitOfWork.Begin();
       try
       {
           //Your database code here
           MyRepository myRepository = new MyRepository(unitOfWork);
           myRepository.Insert(myPoco);
           //You may create other repositories in similar way in same scope of UoW.
   
           unitOfWork.Commit();
       }
       catch
       {
           unitOfWork.Rollback();
           throw;
       }
   }
   

   거래없이 :

   using(DalSession dalSession = new DalSession())
   {
       //Your database code here
       MyRepository myRepository = new MyRepository(dalSession.UnitOfWork);//UoW have no effect here as Begin() is not called.
       myRepository.Insert(myPoco);
   }
   

   이 방법 대신 직접 호출하는 코드의 연결을 노출, 당신은 하나 개의 위치를 ​​제어 할 수 있습니다.

   위의 코드에서 저장소에 대한 자세한 내용은 여기에서 볼 수 있습니다.

   UnitOfWork에 더 많은 단지 거래보다 있습니다. 이 코드는 핸들 전용 트랜잭션하지만. 당신은 추가 역할을 충당하기 위해이 코드를 연장 할 수있다.

from https://stackoverflow.com/questions/40824948/closing-connection-when-using-dapper by cc-by-sa and MIT license