Dapper
2.1.44
https://github.com/dapperlib/dapper/releases에 위치하고 있습니다
Myget Pre-Release Feed : https://www.myget.org/gallery/dapper
| 패키지 | 너겟 안정 | Nuget 프리 릴리스 | 다운로드 | myget |
|---|---|---|---|---|
| 날씬한 | ||||
| dapper.entityFramework | ||||
| dapper.entityframework.strongname | ||||
| dapper.rainbow | ||||
| dapper.sqlbuilder | ||||
| dapper.strongname |
패키지 목적 :
Dapper는 원래 스택 오버플로를 위해 개발되었지만 f/oss입니다. 후원이 환영 받고 초대됩니다 - 페이지 상단의 스폰서 링크를 참조하십시오. Dapper를 후원 한 모든 사람 (개인 또는 조직)에게 큰 감사를 표하지만 특히 큰 감사를드립니다.
Dapper는 DbConnection 인스턴스의 확장 메소드를 통해 ADO.NET 연결을 향상시키는 프로젝트에 추가 할 수있는 NUGET 라이브러리입니다. 이는 동기 및 비동기 데이터 액세스를 모두 지원하여 SQL을 호출하기위한 간단하고 효율적인 API를 제공하며 버퍼링 및 부러되지 않은 쿼리를 모두 허용합니다.
여러 도우미를 제공하지만 주요 API는 다음과 같습니다.
// insert/update/delete etc
var count = connection . Execute ( sql [ , args ] ) ;
// multi-row query
IEnumerable < T > rows = connection . Query < T > ( sql [ , args ] ) ;
// single-row query ({Single|First}[OrDefault])
T row = connection . QuerySingle < T > ( sql [ , args ] ) ; args 될 수있는 곳 (무엇보다) :
Dictionary<string,object>DynamicParameters 인스턴스 public class Dog
{
public int ? Age { get ; set ; }
public Guid Id { get ; set ; }
public string Name { get ; set ; }
public float ? Weight { get ; set ; }
public int IgnoredProperty { get { return 1 ; } }
}
var guid = Guid . NewGuid ( ) ;
var dog = connection . Query < Dog > ( " select Age = @Age, Id = @Id " , new { Age = ( int ? ) null , Id = guid } ) ;
Assert . Equal ( 1 , dog . Count ( ) ) ;
Assert . Null ( dog . First ( ) . Age ) ;
Assert . Equal ( guid , dog . First ( ) . Id ) ; 이 메소드는 SQL을 실행하고 동적 목록을 반환합니다.
예제 사용 :
var rows = connection . Query ( " select 1 A, 2 B union all select 3, 4 " ) . AsList ( ) ;
Assert . Equal ( 1 , ( int ) rows [ 0 ] . A ) ;
Assert . Equal ( 2 , ( int ) rows [ 0 ] . B ) ;
Assert . Equal ( 3 , ( int ) rows [ 1 ] . A ) ;
Assert . Equal ( 4 , ( int ) rows [ 1 ] . B ) ; 예제 사용 :
var count = connection . Execute ( @"
set nocount on
create table #t(i int)
set nocount off
insert #t
select @a a union all select @b
set nocount on
drop table #t" , new { a = 1 , b = 2 } ) ;
Assert . Equal ( 2 , count ) ; 동일한 서명을 사용하면 명령을 여러 번 편리하고 효율적으로 실행할 수 있습니다 (예 : 대량 부하 데이터).
예제 사용 :
var count = connection . Execute ( @"insert MyTable(colA, colB) values (@a, @b)" ,
new [ ] { new { a = 1 , b = 1 } , new { a = 2 , b = 2 } , new { a = 3 , b = 3 } }
) ;
Assert . Equal ( 3 , count ) ; // 3 rows inserted: "1,1", "2,2" and "3,3"기존 컬렉션이 이미 있는 경우 또 다른 예제 사용 :
var foos = new List < Foo >
{
{ new Foo { A = 1 , B = 1 } }
{ new Foo { A = 2 , B = 2 } }
{ new Foo { A = 3 , B = 3 } }
} ;
var count = connection . Execute ( @"insert MyTable(colA, colB) values (@a, @b)" , foos ) ;
Assert . Equal ( foos . Count , count ) ; 이것은 일부 T에 대해 IEnumerable<T> 구현하는 모든 매개 변수에 대해 작동합니다.
Dapper의 주요 기능은 성능입니다. 다음 메트릭은 DB (다양한 구성, 각각 레이블이 붙은)에 대해 SELECT 문을 실행하는 데 걸리는 시간을 보여주고 리턴 된 데이터를 객체에 맵핑합니다.
벤치 마크는 dapper.tests.performance (기부금을 환영합니다!)에서 찾을 수 있으며 다음을 통해 실행할 수 있습니다.
dotnet run --project . b enchmarks D apper.Tests.Performance -c Release -f net8.0 -- -f * --join최신 실행의 출력은 다음과 같습니다.
BenchmarkDotNet v0.13.7, Windows 10 (10.0.19045.3693/22H2/2022Update)
Intel Core i7-3630QM CPU 2.40GHz (Ivy Bridge), 1 CPU, 8 logical and 4 physical cores
.NET SDK 8.0.100
[Host] : .NET 8.0.0 (8.0.23.53103), X64 RyuJIT AVX
ShortRun : .NET 8.0.0 (8.0.23.53103), X64 RyuJIT AVX
| ORM | 방법 | 반품 | 평균 | stddev | 오류 | gen0 | gen1 | gen2 | 할당 |
|---|---|---|---|---|---|---|---|---|---|
| Dapper 캐시 충격 | ExecuteParameters_cache | 무효의 | 96.75 우리 | 0.668 우리 | 1.010 우리 | 0.6250 | - | - | 2184 b |
| Dapper 캐시 충격 | queryfirstparameters_cache | 무효의 | 96.86 우리 | 0.493 우리 | 0.746 우리 | 0.8750 | - | - | 2824 b |
| 손으로 코딩 | sqlcommand | 우편 | 119.70 미국 | 0.706 우리 | 1.067 우리 | 1.3750 | 1.0000 | 0.1250 | 7584 b |
| 손으로 코딩 | 데이터 가능 | 동적 | 126.64 우리 | 1.239 우리 | 1.873 우리 | 3.0000 | - | - | 9576 b |
| sqlmarshal | sqlcommand | 우편 | 132.36 우리 | 1.008 우리 | 1.523 우리 | 2.0000 | 1.0000 | 0.2500 | 11529 b |
| 날씬한 | queryfirstordefault | 우편 | 133.73 우리 | 1.301 우리 | 2.186 우리 | 1.7500 | 1.5000 | - | 11608 b |
| 거대한 | 질문 | 동적 | 133.92 우리 | 1.075 우리 | 1.806 우리 | 2.0000 | 1.7500 | - | 12710 b |
| LINQ ~ DB | 질문 | 우편 | 134.24 우리 | 1.068 우리 | 1.614 우리 | 1.7500 | 1.2500 | - | 10904 b |
| repodb | executequery | 우편 | 135.83 우리 | 1.839 우리 | 3.091 우리 | 1.7500 | 1.5000 | - | 11649 b |
| 날씬한 | '쿼리 (버퍼링)' | 우편 | 136.14 우리 | 1.755 우리 | 2.653 우리 | 2.0000 | 1.5000 | - | 11888 b |
| 거대한 | 질문 | 우편 | 137.96 우리 | 1.485 우리 | 2.244 우리 | 2.2500 | 1.2500 | - | 12201 b |
| 날씬한 | queryfirstordefault | 동적 | 139.04 우리 | 1.507 우리 | 2.279 우리 | 3.5000 | - | - | 11648 b |
| 거대한 | 단일 퀴리 | 동적 | 139.74 우리 | 2.521 우리 | 3.811 우리 | 2.0000 | 1.7500 | - | 12710 b |
| 날씬한 | '쿼리 (버퍼링)' | 동적 | 140.13 우리 | 1.382 우리 | 2.090 미국 | 2.0000 | 1.5000 | - | 11968 b |
| Servicestack | 싱글 비드 | 우편 | 140.76 우리 | 1.147 우리 | 2.192 우리 | 2.5000 | 1.2500 | 0.2500 | 15248 b |
| 날씬한 | 'Contrib Get' | 우편 | 141.09 우리 | 1.394 우리 | 2.108 우리 | 2.0000 | 1.5000 | - | 12440 b |
| 거대한 | 단일 퀴리 | 우편 | 141.17 우리 | 1.941 우리 | 2.935 우리 | 1.7500 | 1.5000 | - | 12201 b |
| 엄청난 | '쿼리 (동적)' | 동적 | 142.01 우리 | 4.957 우리 | 7.494 우리 | 2.0000 | 1.5000 | - | 12342 b |
| LINQ ~ DB | '첫 번째 (컴파일)' | 우편 | 144.59 우리 | 1.295 우리 | 1.958 우리 | 1.7500 | 1.5000 | - | 12128 b |
| repodb | 쿼리 필드 | 우편 | 148.31 우리 | 1.742 우리 | 2.633 우리 | 2.0000 | 1.5000 | 0.5000 | 13938 b |
| 표준 | '읽기 <> (튜플)' | Valuetuple`8 | 148.58 우리 | 2.172 우리 | 3.283 우리 | 2.0000 | 1.7500 | - | 12745 b |
| 표준 | '읽기 <()> (튜플 명명)' ' | Valuetuple`8 | 150.60 우리 | 0.658 우리 | 1.106 우리 | 2.2500 | 2.0000 | 1.2500 | 14562 b |
| repodb | 질문 | 우편 | 152.34 우리 | 2.164 우리 | 3.271 우리 | 2.2500 | 1.5000 | 0.2500 | 14106 b |
| repodb | QueryDynamic | 우편 | 154.15 우리 | 4.108 우리 | 6.210 우리 | 2.2500 | 1.7500 | 0.5000 | 13930 b |
| repodb | 쿼리 어디서 | 우편 | 155.90 우리 | 1.953 우리 | 3.282 우리 | 2.5000 | 0.5000 | - | 14858 b |
| Dapper 캐시 충격 | executenoparameters_nocache | 무효의 | 162.35 우리 | 1.584 우리 | 2.394 우리 | - | - | - | 760 b |
| Dapper 캐시 충격 | ExecuteNoparameters_cache | 무효의 | 162.42 우리 | 2.740 미국 | 4.142 우리 | - | - | - | 760 b |
| Dapper 캐시 충격 | queryfirstnoparameters_cache | 무효의 | 164.35 우리 | 1.206 우리 | 1.824 우리 | 0.2500 | - | - | 1520 b |
| devexpress.xpo | findobject | 우편 | 165.87 우리 | 1.012 우리 | 1.934 우리 | 8.5000 | - | - | 28099 b |
| Dapper 캐시 충격 | queryfirstnoparameters_nocache | 무효의 | 173.87 우리 | 1.178 우리 | 1.781 우리 | 0.5000 | - | - | 1576 b |
| LINQ ~ DB | 첫 번째 | 우편 | 175.21 우리 | 2.292 우리 | 3.851 우리 | 2.0000 | 0.5000 | - | 14041 b |
| EF 6 | sqlquery | 우편 | 175.36 우리 | 2.259 미국 | 3.415 우리 | 4.0000 | 0.7500 | - | 24209 b |
| 표준 | '읽기 <> (클래스)' | 우편 | 186.37 우리 | 1.305 우리 | 2.496 우리 | 3.0000 | 0.5000 | - | 17579 b |
| devexpress.xpo | getobjectbykey | 우편 | 186.78 우리 | 3.407 우리 | 5.151 우리 | 4.5000 | 1.0000 | - | 30114 b |
| 날씬한 | '쿼리 (unfuffered)' | 동적 | 194.62 우리 | 1.335 우리 | 2.019 우리 | 1.7500 | 1.5000 | - | 12048 b |
| 날씬한 | '쿼리 (unfuffered)' | 우편 | 195.01 우리 | 0.888 우리 | 1.343 우리 | 2.0000 | 1.5000 | - | 12008 b |
| devexpress.xpo | 질문 | 우편 | 199.46 우리 | 5.500 미국 | 9.243 우리 | 10.0000 | - | - | 32083 b |
| 베오그라드 | FirstOrdefault | 작업 `1 | 228.70 미국 | 2.181 우리 | 3.665 우리 | 4.5000 | 0.5000 | - | 20555 b |
| EF 코어 | '첫 번째 (컴파일)' | 우편 | 265.45 우리 | 17.745 우리 | 26.828 우리 | 2.0000 | - | - | 7521 b |
| nhibernate | 얻다 | 우편 | 276.02 우리 | 8.029 우리 | 12.139 우리 | 6.5000 | 1.0000 | - | 29885 b |
| nhibernate | HQL | 우편 | 277.74 우리 | 13.032 우리 | 19.703 우리 | 8.0000 | 1.0000 | - | 31886 b |
| nhibernate | 기준 | 우편 | 300.22 우리 | 14.908 우리 | 28.504 우리 | 13.0000 | 1.0000 | - | 57562 b |
| EF 6 | 첫 번째 | 우편 | 310.55 우리 | 27.254 우리 | 45.799 우리 | 13.0000 | - | - | 43309 b |
| EF 코어 | 첫 번째 | 우편 | 317.12 우리 | 1.354 우리 | 2.046 우리 | 3.5000 | - | - | 11306 b |
| EF 코어 | sqlquery | 우편 | 322.34 우리 | 23.990 미국 | 40.314 우리 | 5.0000 | - | - | 18195 b |
| nhibernate | SQL | 우편 | 325.54 우리 | 3.937 우리 | 7.527 우리 | 22.0000 | 1.0000 | - | 80007 b |
| EF 6 | '첫 번째 (추적 없음)' | 우편 | 331.14 우리 | 27.760 미국 | 46.649 우리 | 12.0000 | 1.0000 | - | 50237 b |
| EF 코어 | '첫 번째 (추적 없음)' | 우편 | 337.82 우리 | 27.814 우리 | 46.740 미국 | 3.0000 | 1.0000 | - | 17986 b |
| nhibernate | LINQ | 우편 | 604.74 우리 | 5.549 우리 | 10.610 우리 | 10.0000 | - | - | 46061 b |
| Dapper 캐시 충격 | ExecuteParameters_nocache | 무효의 | 623.42 우리 | 3.978 우리 | 6.684 우리 | 3.0000 | 2.0000 | - | 10001 b |
| Dapper 캐시 충격 | queryfirstparameters_nocache | 무효의 | 630.77 우리 | 3.027 우리 | 4.576 우리 | 3.0000 | 2.0000 | - | 10640 b |
벤치 마크를 실행할 때 릴리스를 컴파일하고 디버거 ( Ctrl + F5 )를 부착하지 않아야합니다.
또는 Frans Bouma의 RawDataAccessBencher Test Suite 또는 Ormbenchmark를 선호 할 수 있습니다.
매개 변수는 일반적으로 익명 클래스로 전달됩니다. 이를 통해 매개 변수의 이름을 쉽게 이름을 지정하고 SQL 스 니펫을 단순히 자르고 붙여 넣고 DB 플랫폼의 쿼리 분석기에서 실행할 수 있습니다.
new { A = 1 , B = " b " } // A will be mapped to the param @A, B to the param @BDynamicParameters 클래스를 사용하여 매개 변수를 동적으로 구축 할 수도 있습니다. 이를 통해 안전 및 성능을 위해 매개 변수를 사용하면서 동적 SQL 문을 구축 할 수 있습니다.
var sqlPredicates = new List < string > ( ) ;
var queryParams = new DynamicParameters ( ) ;
if ( boolExpression )
{
sqlPredicates . Add ( " column1 = @param1 " ) ;
queryParams . Add ( " param1 " , dynamicValue1 , System . Data . DbType . Guid ) ;
} else {
sqlPredicates . Add ( " column2 = @param2 " ) ;
queryParams . Add ( " param2 " , dynamicValue2 , System . Data . DbType . String ) ;
}DynamicParameters는 다른 유형의 기존 객체에서 여러 매개 변수를 복사하는 것을 지원합니다.
var queryParams = new DynamicParameters ( objectOfType1 ) ;
queryParams . AddDynamicParams ( objectOfType2 ) ; IDynamicParameters 인터페이스를 실행하는 객체가 Execute 또는 Query 함수로 전달되면이 인터페이스를 통해 매개 변수 값이 추출됩니다. 분명히,이 목적에 사용할 객체 클래스는 내장 된 DynamicParameters 클래스입니다.
Dapper를 사용하면 IEnumerable<int> 전달할 수 있으며 쿼리를 자동으로 매개 변수화합니다.
예를 들어:
connection . Query < int > ( " select * from (select 1 as Id union all select 2 union all select 3) as X where Id in @Ids " , new { Ids = new int [ ] { 1 , 2 , 3 } } ) ;다음으로 번역됩니다.
select * from ( select 1 as Id union all select 2 union all select 3 ) as X where Id in ( @Ids1 , @Ids2 , @Ids3 ) " // @Ids1 = 1 , @Ids2 = 2 , @Ids2 = 3 Dapper는 Bool 및 Numeric 유형의 문자 그대로 교체를 지원합니다.
connection . Query ( " select * from User where UserTypeId = {=Admin} " , new { UserTypeId . Admin } ) ; 문자 그대로 교체는 매개 변수로 전송되지 않습니다. 이를 통해 더 나은 계획과 필터링 된 인덱스 사용량을 허용하지만 일반적으로 테스트 후에는 드물게 사용해야합니다. 이 기능은 주입되는 값이 실제로 고정 값 (예 : 고정 된 "카테고리 ID", "상태 코드"또는 "쿼리에 특정한"영역 "인 경우 특히 유용합니다. 리터럴을 고려하는 실시간 데이터의 경우 공급자 별 쿼리 힌트를 고려하고 테스트하여 일반 매개 변수로 OPTIMIZE FOR UNKNOWN 와 같은 테스트 할 수도 있습니다.
Dapper의 기본 동작은 SQL을 실행하고 전체 리더를 반품시 버퍼링하는 것입니다. 이것은 대부분의 경우 DB의 공유 잠금을 최소화하고 DB 네트워크 시간을 줄이기 때문에 이상적입니다.
그러나 거대한 쿼리를 실행할 때 메모리 풋 프린트를 최소화하고 필요에 따라 객체 만로드해야 할 수도 있습니다. 이렇게 통과하려면 버퍼링 : Query 메소드에 buffered: false .
Dapper를 사용하면 단일 행을 여러 객체에 매핑 할 수 있습니다. 외부 쿼리 및 열렬한 부하 연관을 피하려는 경우 핵심 기능입니다.
예:
Post 과 User 두 가지 클래스를 고려하십시오
class Post
{
public int Id { get ; set ; }
public string Title { get ; set ; }
public string Content { get ; set ; }
public User Owner { get ; set ; }
}
class User
{
public int Id { get ; set ; }
public string Name { get ; set ; }
} 이제 게시물과 사용자 테이블에 합류하는 쿼리를 매핑하고 싶다고 가정 해 봅시다. 지금까지 2 개의 쿼리 결과를 결합해야한다면 표현하려면 새 객체가 필요하지만이 경우 User 객체를 Post 객체 안에 넣는 것이 더 의미가 있습니다.
이것은 멀티 매핑의 사용 사례입니다. 쿼리가 Post 과 User 객체를 반환 한 다음 Post 과 User 객체를 포함하는 각 행에서 수행 할 내용을 설명하는 기능을 제공합니다. 우리의 경우, 우리는 사용자 객체를 가져 와서 게시물 객체 안에 넣고 싶습니다. 그래서 우리는 기능을 작성합니다.
( post , user ) => { post . Owner = user ; return post ; } Query 메소드에 대한 3 가지 유형 인수는 행을 제외시키기 위해 Dapper가 사용하는 객체와 반환 할 내용을 지정합니다. 우리는 두 행을 Post 와 User 의 조합으로 해석 할 것이며 Post 객체를 되돌리고 있습니다. 따라서 유형 선언이됩니다
< Post , User , Post >모든 것이 합쳐지고 다음과 같이 보입니다.
var sql =
@"select * from #Posts p
left join #Users u on u.Id = p.OwnerId
Order by p.Id" ;
var data = connection . Query < Post , User , Post > ( sql , ( post , user ) => { post . Owner = user ; return post ; } ) ;
var post = data . First ( ) ;
Assert . Equal ( " Sams Post1 " , post . Content ) ;
Assert . Equal ( 1 , post . Id ) ;
Assert . Equal ( " Sam " , post . Owner . Name ) ;
Assert . Equal ( 99 , post . Owner . Id ) ; Dapper는 ID 열의 이름이 Id 또는 id 가정을 통해 반환 된 행을 분할 할 수 있습니다. 기본 키가 다르거나 Id 이외의 지점에서 행을 분할하려면 옵션 splitOn 매개 변수를 사용하십시오.
Dapper를 사용하면 단일 쿼리에서 여러 결과 그리드를 처리 할 수 있습니다.
예:
var sql =
@"
select * from Customers where CustomerId = @id
select * from Orders where CustomerId = @id
select * from Returns where CustomerId = @id" ;
using ( var multi = connection . QueryMultiple ( sql , new { id = selectedId } ) )
{
var customer = multi . Read < Customer > ( ) . Single ( ) ;
var orders = multi . Read < Order > ( ) . ToList ( ) ;
var returns = multi . Read < Return > ( ) . ToList ( ) ;
.. .
} Dapper는 저장된 Procs를 완전히지지합니다.
var user = cnn . Query < User > ( " spGetUser " , new { Id = 1 } ,
commandType : CommandType . StoredProcedure ) . SingleOrDefault ( ) ;더 멋진 것을 원한다면 할 수 있습니다.
var p = new DynamicParameters ( ) ;
p . Add ( " @a " , 11 ) ;
p . Add ( " @b " , dbType : DbType . Int32 , direction : ParameterDirection . Output ) ;
p . Add ( " @c " , dbType : DbType . Int32 , direction : ParameterDirection . ReturnValue ) ;
cnn . Execute ( " spMagicProc " , p , commandType : CommandType . StoredProcedure ) ;
int b = p . Get < int > ( " @b " ) ;
int c = p . Get < int > ( " @c " ) ; dapper는 varchar params를 지원합니다. 매개 변수를 사용하여 varchar 열에서 WHERE 절을 실행하는 경우 이러한 방식으로 전달하십시오.
Query < Thing > ( " select * from Thing where Name = @Name " , new { Name = new DbString { Value = " abcde " , IsFixedLength = true , Length = 10 , IsAnsi = true } } ) ;SQL Server에서는 비 유니 코드를 쿼리 할 때 유니 코드 및 ANSI를 쿼리 할 때 유니 코드를 사용하는 것이 중요합니다.
일반적으로 주어진 테이블의 모든 행을 동일한 데이터 유형으로 취급하려고합니다. 그러나 다른 행을 다른 데이터 유형으로 구문 분석 할 수있는 것이 유용한 상황이 있습니다. 이곳은 IDataReader.GetRowParser 편리한 곳입니다.
열이있는 "Shapes"라는 데이터베이스 테이블이 Id , Type 및 Data 사용하여 유형 열의 값을 기반으로 Circle , Square 또는 Triangle 객체에 행을 구문 분석하려고한다고 상상해보십시오.
var shapes = new List < IShape > ( ) ;
using ( var reader = connection . ExecuteReader ( " select * from Shapes " ) )
{
// Generate a row parser for each type you expect.
// The generic type <IShape> is what the parser will return.
// The argument (typeof(*)) is the concrete type to parse.
var circleParser = reader . GetRowParser < IShape > ( typeof ( Circle ) ) ;
var squareParser = reader . GetRowParser < IShape > ( typeof ( Square ) ) ;
var triangleParser = reader . GetRowParser < IShape > ( typeof ( Triangle ) ) ;
var typeColumnIndex = reader . GetOrdinal ( " Type " ) ;
while ( reader . Read ( ) )
{
IShape shape ;
var type = ( ShapeType ) reader . GetInt32 ( typeColumnIndex ) ;
switch ( type )
{
case ShapeType . Circle :
shape = circleParser ( reader ) ;
break ;
case ShapeType . Square :
shape = squareParser ( reader ) ;
break ;
case ShapeType . Triangle :
shape = triangleParser ( reader ) ;
break ;
default :
throw new NotImplementedException ( ) ;
}
shapes . Add ( shape ) ;
}
} MySQL 커넥터와 함께 비 매개 변수 SQL 변수를 사용하려면 연결 문자열에 다음 옵션을 추가해야합니다.
Allow User Variables=True
Dapper에 매핑 할 속성을 제공하지 않도록하십시오.
Dapper는 실행되는 모든 쿼리에 대한 정보를 캐시하여 객체를 빠르게 구체화하고 매개 변수를 빠르게 처리 할 수 있습니다. 현재 구현은이 정보를 ConcurrentDictionary 객체로 캐시합니다. 한 번만 사용되는 진술은이 캐시에서 일상적으로 플러시됩니다. 그럼에도 불구하고 매개 변수를 사용하지 않고 즉시 SQL 문자열을 생성하는 경우 메모리 문제에 도달 할 수 있습니다.
Dapper의 단순성은 Orms와 함께 제공되는 많은 기능이 제거되었음을 의미합니다. 그것은 95% 시나리오에 대해 걱정하고 대부분의 시간에 필요한 도구를 제공합니다. 모든 문제를 해결하려고 시도하는 것은 아닙니다.
Dapper에는 DB 특정 구현 세부 사항이 없으며 SQLITE, SQL CE, Firebird, Oracle, Mariadb, MySQL, PostgreSQL 및 SQL Server를 포함한 모든 .NET Ado 제공 업체에서 작동합니다.
Dapper에는 테스트 프로젝트에 포괄적 인 테스트 스위트가 있습니다.
Dapper는 Stack Overflow에서 생산 사용 중입니다.
