/// <summary>
/// 생성자
/// </summary>
/// <param name="nameMapper">name mapper</param>
/// <param name="persistentFactory">Persistent object 생성 delegate</param>
protected AdoPersisterBase(INameMapper nameMapper, Func <TPersist> persistentFactory = null)
{
nameMapper.ShouldNotBeNull("nameMapper");
NameMapper = nameMapper;
FactoryFunction = persistentFactory ?? ActivatorTool.CreateInstance <TPersist>;
}
/// <summary>
/// <paramref name="cmd"/>를 실행하여, 결과 셋을 Persistent Object의 컬렉션으로 매핑합니다.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="db"></param>
/// <param name="cmd"></param>
/// <param name="mapObjectFactory"></param>
/// <param name="nameMapper"></param>
/// <param name="firstResult"></param>
/// <param name="maxResults"></param>
/// <param name="additionalMapping"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static Task <IList <T> > ExecuteMapObject <T>(this SQLiteDatabase db,
SQLiteCommand cmd,
Func <T> mapObjectFactory,
INameMapper nameMapper,
int firstResult,
int maxResults,
Action <IDataReader, T> additionalMapping,
params IAdoParameter[] parameters)
{
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug("DataReader를 열어, 수형[{2}]로 빌드합니다... CommandText=[{0}], Parameters=[{1}]",
cmd.CommandText, cmd.Parameters.CollectionToString(), typeof(T).FullName);
}
return
(ExecuteReaderAsync(db, cmd, parameters)
.ContinueWith(task => {
using (var reader = task.Result)
return AdoTool.Map <T>(reader,
mapObjectFactory,
nameMapper,
firstResult,
maxResults,
additionalMapping);
},
TaskContinuationOptions.ExecuteSynchronously));
}
///<summary>
/// DbCommand를 실행해 얻은 DataReader를 통해 지정된 형식의 인스턴스를 만든다.
///</summary>
/// <typeparam name="T">Type of Persistent object</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="nameMapper">컬럼명과 속성명 Mapper</param>
/// <param name="cmd">실행할 DbCommand</param>
/// <param name="parameters">Procedure 인자</param>
/// <returns>Collection of Persistent object</returns>
public static Task <IList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
DbCommand cmd,
params IAdoParameter[] parameters) where T : class
{
return(Task.Factory.StartNew(() => repository.ExecuteInstance <T>(nameMapper, cmd, parameters)));
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,INameMapper,DbCommand,IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMapper">DataReader 컬럼과 엔티티의 속성명의 Name 매퍼</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="pageIndex">결과셋의 Page Index (0부터 시작)</param>
/// <param name="pageSize">결과셋 Paging 시의 Page Size</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IPagingList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
Action <IDataReader, T> additionalMapping,
string query,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters) where T : class
{
nameMapper.ShouldNotBeNull("nameMapper");
query.ShouldNotBeWhiteSpace("query");
if (IsDebugEnabled)
{
log.Debug("비동기적으로 ExecuteReader<{0}>()을 수행하고, 결과를 IList<{0}> 으로 반환합니다... query=[{1}]", typeof(T).FullName, query);
}
return
(Task.Factory.StartNew(() => {
using (var cmd = repository.GetCommand(query))
return repository.ExecuteInstance <T>(nameMapper,
additionalMapping,
cmd,
pageIndex,
pageSize,
parameters);
}));
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,INameMapper,System.Data.Common.DbCommand,IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMapper">DataReader 컬럼과 엔티티의 속성명의 Name 매퍼</param>
/// <param name="targetFactory">대상 객체 생성 함수</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작)</param>
/// <param name="maxResults">최대 레코드 갯수(0이면 끝까지)</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IList <T> > ExecuteInstanceAsParallelAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
Func <T> targetFactory,
int firstResult,
int maxResults,
Action <AdoResultRow, T> additionalMapping,
string query,
params IAdoParameter[] parameters)
{
nameMapper.ShouldNotBeNull("nameMapper");
targetFactory.ShouldNotBeNull("targetFactory");
query.ShouldNotBeWhiteSpace("query");
if (IsDebugEnabled)
{
log.Debug("비동기적으로 ExecuteReader()을 수행하고, 병렬로 매핑하여 결과를 IList<{0}>으로 매핑합니다... " +
"query=[{1}], firstResult=[{2}], maxResults=[{3}]", typeof(T).Name, query, firstResult, maxResults);
}
return
(Task.Factory
.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return reader.MapAsParallel <T>(targetFactory, nameMapper, firstResult, maxResults,
additionalMapping);
}));
}
/// <summary>
/// ExecuteInstance() 를 비동기적으로 수행하여,
/// DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMapper">DataReader 컬럼과 엔티티의 속성명의 Name 매퍼</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
string query,
params IAdoParameter[] parameters) where T : class
{
return(ExecuteInstanceAsync(repository, nameMapper, (Action <IDataReader, T>)null, query, parameters));
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,INameMapper,DbCommand,IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMapper">DataReader 컬럼과 엔티티의 속성명의 Name 매퍼</param>
/// <param name="targetFactory">대상 객체 생성 Factory</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="pageIndex">결과셋의 Page Index (0부터 시작)</param>
/// <param name="pageSize">결과셋 Paging 시의 Page Size</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IPagingList <T> > ExecuteInstanceAsParallelAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
Func <T> targetFactory,
Action <AdoResultRow, T> additionalMapping,
string query,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters)
{
nameMapper.ShouldNotBeNull("nameMapper");
query.ShouldNotBeWhiteSpace("query");
if (IsDebugEnabled)
{
log.Debug("비동기적으로 ExecuteReader()을 수행하고, 병렬 방식으로 매핑하여 결과를 IPageList<{0}>으로 반환하는 Task를 빌드합니다... query=[{1}]",
typeof(T).Name, query);
}
var itemsTask = Task.Factory.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return(reader.MapAsParallel <T>(targetFactory,
nameMapper,
pageIndex * pageSize,
pageSize,
additionalMapping));
});
var totalItemCountTask = repository.CountAsync(query, parameters);
var result = new PagingList <T>(itemsTask.Result, pageIndex, pageSize, totalItemCountTask.Result);
return(Task.Factory.FromResult((IPagingList <T>)result));
}
/// <summary>
/// IDataReader 정보를 병렬 방식으로 매핑을 수행하여, 컬렉션을 반환합니다.
/// </summary>
/// <typeparam name="T">매핑 대상 수형</typeparam>
/// <param name="reader">DataReader</param>
/// <param name="nameMapper">컬럼명-속성명 Mapper</param>
/// <param name="targetFactory">대상 수형 Factory 함수</param>
/// <param name="propertyExprsToExclude">매핑 작업에서 제외할 속성 표현식 (예: user=>user.Password)</param>
/// <returns>매핑된 객체의 컬렉션</returns>
public static IList <T> MapAsParallel <T>(this IDataReader reader,
Func <T> targetFactory,
INameMapper nameMapper,
params Expression <Func <T, object> >[] propertyExprsToExclude)
{
return(MapAsParallel(reader, targetFactory, nameMapper, 0, 0, (Action <AdoResultRow, T>)null, propertyExprsToExclude));
}
/// <summary>
/// <paramref name="sqlCommand"/>를 실행하여, 결과 셋을 Persistent Object의 컬렉션으로 매핑합니다.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sqlDatabase"></param>
/// <param name="sqlCommand"></param>
/// <param name="mapObjectFactory"></param>
/// <param name="nameMapper"></param>
/// <param name="firstResult"></param>
/// <param name="maxResults"></param>
/// <param name="additionalMapping"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static Task <IList <T> > ExecuteMapObject <T>(this SqlDatabase sqlDatabase,
SqlCommand sqlCommand,
Func <T> mapObjectFactory,
INameMapper nameMapper,
int firstResult,
int maxResults,
Action <IDataReader, T> additionalMapping,
params IAdoParameter[] parameters)
{
sqlCommand.ShouldNotBeNull("sqlCommand");
if (IsDebugEnabled)
{
log.Debug("SqlCommand.ExecuteMapObject 를 비동기 방식으로 실행합니다. CommandText=[{0}], Parameters=[{1}]",
sqlCommand.CommandText, sqlCommand.Parameters.CollectionToString());
}
return
(ExecuteReaderAsync(sqlDatabase, sqlCommand, parameters)
.ContinueWith(antecedent => {
using (var reader = antecedent.Result)
return AdoTool.Map <T>(reader, mapObjectFactory, nameMapper, firstResult, maxResults,
additionalMapping);
},
TaskContinuationOptions.ExecuteSynchronously));
}
public DataServiceImpl(IAdoRepository adoRepository, INameMapper nameMapper) {
adoRepository.ShouldNotBeNull("adoRepository");
nameMapper.ShouldNotBeNull("nameMapper");
AdoRepository = adoRepository;
NameMapper = nameMapper;
}
public ProxyMapper(Binding binding, IEndpointBehavior endpointBehavior, INameMapper nameMapper)
{
_generator = new ProxyGenerator();
_nameMapper = nameMapper;
_binding = binding;
_endpointBehavior = endpointBehavior;
}
/// <summary>
/// <paramref name="table"/>의 정보를 Persistent object로 변환하여 제공합니다.
/// </summary>
/// <typeparam name="T">Persistent object 의 수형</typeparam>
/// <param name="table"><see cref="DataTable"/>원본 데이타 테이블</param>
/// <param name="nameMapper">컬럼명-속성명 매퍼</param>
/// <param name="propertyExprsToExclude">매핑에서 제외할 대상 객체의 속성</param>
/// <returns>Persistent object의 컬렉션</returns>
public static IList <T> Map <T>(this DataTable table, INameMapper nameMapper,
params Expression <Func <T, object> >[] propertyExprsToExclude) where T : class
{
var propertyNamesToExclude = propertyExprsToExclude.Select(expr => expr.Body.FindMemberName()).ToArray();
return(Map(table.CreateDataReader(), ActivatorTool.CreateInstance <T>, table.NameMapping(nameMapper, propertyNamesToExclude)));
}
/// <summary>
/// 지정된 IDataReader로부터 컬럼명-속성명 매퍼(<paramref name="nameMapper"/>) 를 기준으로, 대상 객체를 인스턴싱하고, 속성에 값을 설정하여 반환합니다.
/// </summary>
/// <typeparam name="T">대상 객체의 수형</typeparam>
/// <param name="reader">DataReader 객체</param>
/// <param name="targetFactory">대상 객체 생성용 Factory</param>
/// <param name="nameMapper">DB 컬럼명- 클래스 속성명 매핑 규칙( <seealso cref="TrimNameMapper"/>, <seealso cref="CapitalizeNameMapper"/> 등)</param>
/// <param name="additionalMapping">컬럼-속성 단순 값 매핑 이외에 부가적인 매핑을 수행하기 위해 제공되는 델리게이트</param>
/// <param name="propertyExprsToExclude">매핑에서 제외할 대상 객체의 속성</param>
/// <returns>매핑된 대상 객체의 컬렉션</returns>
public static IList <T> Map <T>(this IDataReader reader,
Func <T> targetFactory,
INameMapper nameMapper,
Action <IDataReader, T> additionalMapping,
params Expression <Func <T, object> >[] propertyExprsToExclude)
{
return(Map(reader, targetFactory, nameMapper, 0, 0, additionalMapping, propertyExprsToExclude));
}
public DataServiceImpl(IAdoRepository adoRepository, INameMapper nameMapper)
{
adoRepository.ShouldNotBeNull("adoRepository");
nameMapper.ShouldNotBeNull("nameMapper");
AdoRepository = adoRepository;
NameMapper = nameMapper;
}
/// <summary>
/// 지정된 IDataReader로부터 컬럼명-속성명 매퍼(<paramref name="nameMapper"/>) 를 기준으로, 대상 객체를 인스턴싱하고, 속성에 값을 설정하여 반환합니다.
/// </summary>
/// <typeparam name="T">대상 객체의 수형</typeparam>
/// <param name="reader">DataReader 객체</param>
/// <param name="targetFactory">대상 객체 생성용 Factory</param>
/// <param name="nameMapper">DB 컬럼명- 클래스 속성명 매핑 규칙( <seealso cref="TrimNameMapper"/>, <seealso cref="CapitalizeNameMapper"/> 등)</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작합니다. null이면 0으로 간주)</param>
/// <param name="maxResults">매핑할 최대 레코드 수 (0이면, IDataReader의 끝까지 매핑합니다)</param>
/// <param name="propertyExprsToExclude">매핑에서 제외할 대상 객체의 속성</param>
/// <returns>매핑된 대상 객체의 컬렉션</returns>
public static IList <T> Map <T>(this IDataReader reader,
Func <T> targetFactory,
INameMapper nameMapper,
int firstResult,
int maxResults,
params Expression <Func <T, object> >[] propertyExprsToExclude)
{
return(Map(reader, targetFactory, nameMapper, firstResult, maxResults, (Action <IDataReader, T>)null, propertyExprsToExclude));
}
/// <summary>
/// 지정된 IDataReader로부터 컬럼명-속성명 매퍼(<paramref name="nameMapper"/>) 를 기준으로, 대상 객체를 인스턴싱하고, 속성에 값을 설정하여 반환합니다.
/// </summary>
/// <typeparam name="T">대상 객체의 수형</typeparam>
/// <param name="reader">DataReader 객체</param>
/// <param name="nameMapper">DB 컬럼명- 클래스 속성명 매핑 규칙( <seealso cref="TrimNameMapper"/>, <seealso cref="CapitalizeNameMapper"/> 등)</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작합니다. null이면 0으로 간주)</param>
/// <param name="maxResults">매핑할 최대 레코드 수 (0이면, IDataReader의 끝까지 매핑합니다)</param>
/// <param name="propertyExprsToExclude">매핑에서 제외할 대상 객체의 속성</param>
/// <returns>매핑된 대상 객체의 컬렉션</returns>
public static IList <T> Map <T>(this IDataReader reader,
INameMapper nameMapper,
int firstResult,
int maxResults,
params Expression <Func <T, object> >[] propertyExprsToExclude) where T : new()
{
return(Map(reader, ActivatorTool.CreateInstance <T>, nameMapper, firstResult, maxResults, (Action <IDataReader, T>)null,
propertyExprsToExclude));
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository, INameMapper,System.Data.Common.DbCommand,IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMapper">DataReader 컬럼과 엔티티의 속성명의 Name 매퍼</param>
/// <param name="targetFactory">대상 객체 생성 함수</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IList <T> > ExecuteInstanceAsParallelAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
Func <T> targetFactory,
Action <AdoResultRow, T> additionalMapping,
string query,
params IAdoParameter[] parameters)
{
return(ExecuteInstanceAsParallelAsync(repository, nameMapper, targetFactory, 0, 0, additionalMapping, query, parameters));
}
public static IEnumerable<Expression> GetDistinctColumns(INameMapper mapper, Expression expr)
{
var dce = new DistinctColumnExtractor(mapper);
dce.Visit(expr);
if (dce._Columns.Count == 0)
throw new InvalidOperationException("Unable to find any sort/equality columns in this expression.");
return dce._Columns.ToReadOnly();
}
/// <summary>
/// Adds a new event log source entry to the collection using the specified log name and source name
/// </summary>
/// <param name="logName">Name of the event log</param>
/// <param name="sourceName">Name of the event source</param>
/// <param name="logNameMapper">Optional mapper for the log name</param>
/// <param name="sourceNameMapper">Optional mapper for the log source</param>
public void Add(string logName, string sourceName, INameMapper logNameMapper = null,
INameMapper sourceNameMapper = null)
{
if (logNameMapper != null) logName = logNameMapper.Map(logName);
if (sourceNameMapper != null) sourceName = sourceNameMapper.Map(sourceName);
if (!_logSourceData.Any(i => i.LogName == logName && i.Source == sourceName))
{
_logSourceData.Add(new EventSourceCreationData(sourceName, logName));
}
}
/// <summary>
/// Merges all Windows event log source types from the specified assembly with the
/// creation data.
/// </summary>
/// <param name="assembly">Assembly to scan for perfromance counter types</param>
/// <param name="logNameMapper">Optional mapper for the log name</param>
/// <param name="sourceNameMapper">Optional mapper for the log source</param>
public void MergeSourcesFromAssembly(Assembly assembly, INameMapper logNameMapper = null,
INameMapper sourceNameMapper = null)
{
foreach (var type in assembly
.GetTypes()
.Where(type => type.IsSubclassOf(typeof(LogEventBase)) &&
type.GetCustomAttribute <SkipLogSourceInstallationAttribute>() == null))
{
Add(type, logNameMapper, sourceNameMapper);
}
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,Mappers.INameMapper,System.Data.Common.DbCommand,IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMapper">DataReader 컬럼과 엔티티의 속성명의 Name 매퍼</param>
/// <param name="targetFactory">대상 객체 생성 Factory</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="pageIndex">결과셋의 Page Index (0부터 시작)</param>
/// <param name="pageSize">결과셋 Paging 시의 Page Size</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IPagingList <T> > ExecuteInstanceAsParallelAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
Func <T> targetFactory,
string query,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters)
{
return(repository.ExecuteInstanceAsParallelAsync(nameMapper, targetFactory, (Action <AdoResultRow, T>)null, query, pageIndex,
pageSize, parameters));
}
/// <summary>
/// <paramref name="table"/>의 정보를 Persistent object로 변환하여 제공합니다.
/// </summary>
/// <typeparam name="T">Persistent object 의 수형</typeparam>
/// <param name="table"><see cref="DataTable"/>원본 데이타 테이블</param>
/// <param name="targetFactory">Persistent object 생성 함수</param>
/// <param name="nameMapper">컬럼명-속성명 매퍼</param>
/// <param name="propertyExprsToExclude">매핑에서 제외할 대상 객체의 속성</param>
/// <returns>Persistent object의 컬렉션</returns>
public static IList <T> Map <T>(this DataTable table,
Func <T> targetFactory,
INameMapper nameMapper,
params Expression <Func <T, object> >[] propertyExprsToExclude)
{
var propertyNamesToExclude = propertyExprsToExclude.Select(expr => expr.Body.FindMemberName()).ToArray();
return(Map(table.CreateDataReader(),
targetFactory,
table.NameMapping(nameMapper, propertyNamesToExclude)));
}
/// <summary>
/// 지정된 Command를 실행하여, 결과 셋을 Paging하여, 지정된 Page에 해당하는 정보만 Persistent Object로 빌드하여 반환한다.
/// </summary>
/// <typeparam name="T">Persistent Object의 수형</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="nameMapper">컬럼명:속성명의 매핑정보를 가진 Mapper</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="cmd">실행할 DbCommand</param>
/// <param name="pageIndex">결과셋의 Page Index (0부터 시작)</param>
/// <param name="pageSize">결과셋 Paging 시의 Page Size</param>
/// <param name="parameters">DbCommand 실행시의 Parameter 정보</param>
/// <returns>Paging된 Persistent Object의 List</returns>
public static Task <IPagingList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
Action <IDataReader, T> additionalMapping,
DbCommand cmd,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters) where T : class
{
return
(Task.Factory.StartNew(
() => repository.ExecuteInstance <T>(nameMapper, additionalMapping, cmd, pageIndex, pageSize, parameters)));
}
/// <summary>
/// <paramref name="reader"/>를 읽어, <see cref="ResultRow"/>의 컬렉션인 <see cref="ResultSet"/>을 빌드합니다.
/// </summary>
/// <param name="reader">DataReader</param>
/// <param name="nameMapper">컬럼명을 속성명으로 매핑해주는 매퍼입니다.</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작)</param>
/// <param name="maxResults">최대 레코드 수</param>
/// <returns><see cref="ResultSet"/> 인스턴스</returns>
public static ResultSet CreateResultSet(this IDataReader reader, INameMapper nameMapper, int firstResult, int maxResults)
{
reader.ShouldNotBeNull("reader");
if (nameMapper == null)
{
nameMapper = new SameNameMapper();
}
if (IsDebugEnabled)
{
log.Debug("IDataReader로부터 정보를 읽어 ResultRow들을 만들어 ResultSet 으로 빌드합니다...");
}
var resultSet = new ResultSet();
while (firstResult-- > 0)
{
if (reader.Read() == false)
{
return(resultSet);
}
}
if (maxResults <= 0)
{
maxResults = int.MaxValue;
}
resultSet.FieldNames = reader.GetFieldNames();
var rowIndex = 0;
while (reader.Read() && rowIndex++ < maxResults)
{
var row = new ResultRow();
foreach (var fieldName in resultSet.FieldNames)
{
row.Add(nameMapper.MapToPropertyName(fieldName), reader.AsValue(fieldName));
}
resultSet.Add(row);
}
if (IsDebugEnabled)
{
log.Debug("IDataReader로부터 정보를 읽어 ResultSet을 빌드했습니다!!! Row Count=[{0}]", resultSet.Count);
}
return(resultSet);
}
/// <summary>
/// <paramref name="reader"/>의 레코드 정보를 <paramref name="nameMapper"/>를 통해 매핑을 수행하는데, 계속조건 (<paramref name="continuationCondition"/>) 이 만족할때까지만 수행한다.
/// </summary>
/// <typeparam name="T">대상 객체</typeparam>
/// <param name="reader">IDataReader 객체</param>
/// <param name="targetFactory">대상 객체 생성용 Factory</param>
/// <param name="nameMapper">DB 컬럼명- 클래스 속성명 매퍼</param>
/// <param name="continuationCondition">진행 조건 (False가 나올 때까지 진행합니다)</param>
/// <param name="additionalMapping">컬럼-속성 단순 값 매핑 이외에 부가적인 매핑을 수행하기 위해 제공되는 델리게이트</param>
/// <param name="propertyExprsToExclude">매핑에서 제외할 대상 객체의 속성</param>
/// <returns>매핑된 대상 객체 컬렉션</returns>
public static IEnumerable <T> MapWhile <T>(this IDataReader reader,
Func <T> targetFactory,
INameMapper nameMapper,
Func <IDataReader, bool> continuationCondition,
Action <IDataReader, T> additionalMapping,
params Expression <Func <T, object> >[] propertyExprsToExclude)
{
targetFactory.ShouldNotBeNull("targetFactory");
nameMapper.ShouldNotBeNull("nameMapper");
var propertyNamesToExclude = propertyExprsToExclude.Select(expr => expr.Body.FindMemberName()).ToArray();
var nameMap = reader.NameMapping(nameMapper, propertyNamesToExclude);
return(MapWhile(reader, targetFactory, nameMap, continuationCondition, additionalMapping));
}
/// <summary>
/// Adds a new event log source entry to the collection using the specified log name and source name
/// </summary>
/// <param name="logName">Name of the event log</param>
/// <param name="sourceName">Name of the event source</param>
/// <param name="logNameMapper">Optional mapper for the log name</param>
/// <param name="sourceNameMapper">Optional mapper for the log source</param>
public void Add(string logName, string sourceName, INameMapper logNameMapper = null,
INameMapper sourceNameMapper = null)
{
if (logNameMapper != null)
{
logName = logNameMapper.Map(logName);
}
if (sourceNameMapper != null)
{
sourceName = sourceNameMapper.Map(sourceName);
}
if (!_logSourceData.Any(i => i.LogName == logName && i.Source == sourceName))
{
_logSourceData.Add(new EventSourceCreationData(sourceName, logName));
}
}
/// <summary>
/// Adds a new event log source entry to the collection using the specified log event type's metadata
/// </summary>
/// <param name="logEventType"></param>
/// <param name="logNameMapper">Optional mapper for the log name</param>
/// <param name="sourceNameMapper">Optional mapper for the log source</param>
public void Add(Type logEventType, INameMapper logNameMapper = null,
INameMapper sourceNameMapper = null)
{
if (!logEventType.IsSubclassOf(typeof (LogEventBase)))
{
throw new InvalidOperationException(
string.Format("Add must be called with a LogEventBase derived type. "
+ "{0} is not an appropriate type.", logEventType));
}
var eventInstance = Activator.CreateInstance(logEventType) as LogEventBase;
if (eventInstance != null)
{
Add(eventInstance.LogName, eventInstance.Source, logNameMapper, sourceNameMapper);
}
}
/// <summary>
/// <see cref="IAdoRepository.ExecuteInstance{T}(System.Func{System.Data.IDataReader,T},System.Data.Common.DbCommand,NFramework.Data.IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 <paramref name="filter"/> 에 만족하는 레코드만 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="targetFactory">대상 객체 생성용 Factory</param>
/// <param name="nameMapper">DB 컬럼명- 클래스 속성명 매퍼</param>
/// <param name="filter">매핑할 Row를 선별할 필터 함수</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IEnumerable <T> > ExecuteInstanceIfAsync <T>(this IAdoRepository repository,
Func <T> targetFactory,
INameMapper nameMapper,
Func <IDataReader, bool> filter,
string query,
params IAdoParameter[] parameters) where T : class
{
targetFactory.ShouldNotBeNull("targetFactory");
nameMapper.ShouldNotBeNull("nameMapper");
filter.ShouldNotBeNull("filter");
return(Task.Factory.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return reader.MapIf <T>(targetFactory, nameMapper, filter, null);
}));
}
/// <summary>
/// Adds a new event log source entry to the collection using the specified log event type's metadata
/// </summary>
/// <param name="logEventType"></param>
/// <param name="logNameMapper">Optional mapper for the log name</param>
/// <param name="sourceNameMapper">Optional mapper for the log source</param>
public void Add(Type logEventType, INameMapper logNameMapper = null,
INameMapper sourceNameMapper = null)
{
if (!logEventType.IsSubclassOf(typeof(LogEventBase)))
{
throw new InvalidOperationException(
string.Format("Add must be called with a LogEventBase derived type. "
+ "{0} is not an appropriate type.", logEventType));
}
var eventInstance = Activator.CreateInstance(logEventType) as LogEventBase;
if (eventInstance != null)
{
Add(eventInstance.LogName, eventInstance.Source, logNameMapper, sourceNameMapper);
}
}
/// <summary>
/// <see cref="IAdoRepository.ExecuteInstance{T}(System.Func{System.Data.IDataReader,T},System.Data.Common.DbCommand,NFramework.Data.IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// <paramref name="continuationCondition"/> 조건이 만족할 동안만, DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="targetFactory">대상 객체 생성용 Factory</param>
/// <param name="nameMapper">DB 컬럼명- 클래스 속성명 매퍼</param>
/// <param name="continuationCondition">매핑을 계속할 조건인지 판단하는 델리게이트</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IEnumerable <T> > ExecuteInstanceWhileAsync <T>(this IAdoRepository repository,
Func <T> targetFactory,
INameMapper nameMapper,
Func <IDataReader, bool> continuationCondition,
string query,
params IAdoParameter[] parameters) where T : class
{
nameMapper.ShouldNotBeNull("nameMapper");
continuationCondition.ShouldNotBeNull("continuationCondition");
return(Task.Factory.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return reader.MapWhile <T>(ActivatorTool.CreateInstance <T>,
nameMapper,
continuationCondition,
null);
}));
}
///<summary>
/// DbCommand를 실행해 얻은 DataReader를 통해 지정된 형식의 인스턴스를 만든다.
///</summary>
/// <typeparam name="T">Type of Persistent object</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="nameMapper">컬럼명과 속성명 Mapper</param>
/// <param name="cmd">실행할 DbCommand</param>
/// <param name="parameters">Procedure 인자</param>
/// <returns>Collection of Persistent object</returns>
public static IList <T> ExecuteInstance <T>(this IAdoRepository repository,
INameMapper nameMapper,
DbCommand cmd,
params IAdoParameter[] parameters) where T : class
{
nameMapper.ShouldNotBeNull("nameMapper");
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug("DataReader를 INameMapper를 통해 지정된 Class의 인스턴스들을 생성합니다. " +
"persistent=[{0}], nameMapper=[{1}], commandText=[{2}], parameters=[{3}]",
typeof(T).FullName, nameMapper, cmd.CommandText, parameters.CollectionToString());
}
using (var reader = repository.ExecuteReader(cmd, parameters))
return(reader.Map <T>(ActivatorTool.CreateInstance <T>, reader.NameMapping(nameMapper)));
}
/// <summary>
/// IDataReader 정보를 병렬 방식으로 매핑을 수행하여, 컬렉션을 반환합니다.
/// </summary>
/// <typeparam name="T">매핑 대상 수형</typeparam>
/// <param name="reader">DataReader</param>
/// <param name="nameMapper">컬럼명-속성명 Mapper</param>
/// <param name="targetFactory">대상 수형 Factory 함수</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작합니다. null이면 0으로 간주)</param>
/// <param name="maxResults">매핑할 최대 레코드 수 (0이면, IDataReader의 끝까지 매핑합니다)</param>
/// <param name="additionalMapping">추가 매핑 작업을 수행할 델리게이트</param>
/// <param name="propertyExprsToExclude">매핑 작업에서 제외할 속성 표현식 (예: user=>user.Password)</param>
/// <returns>매핑된 객체의 컬렉션</returns>
public static IList <T> MapAsParallel <T>(this IDataReader reader,
Func <T> targetFactory,
INameMapper nameMapper,
int firstResult,
int maxResults,
Action <AdoResultRow, T> additionalMapping,
params Expression <Func <T, object> >[] propertyExprsToExclude)
{
reader.ShouldNotBeNull("reader");
if (nameMapper == null)
{
nameMapper = IoC.TryResolve <INameMapper, TrimNameMapper>(LifestyleType.Thread);
}
var propertyNamesToExclude = propertyExprsToExclude.Select(expr => expr.Body.FindMemberName()).ToArray();
var nameMap = reader.NameMapping(nameMapper, propertyNamesToExclude);
return(MapAsParallel(reader, targetFactory, nameMap, firstResult, maxResults, additionalMapping));
}
/// <summary>
/// 지정된 Command를 실행하여, 결과 셋을 Paging하여, 지정된 Page에 해당하는 정보만 Persistent Object로 빌드하여 반환한다.
/// </summary>
/// <typeparam name="T">Persistent Object의 수형</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="nameMapper">컬럼명:속성명의 매핑정보를 가진 Mapper</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="cmd">실행할 DbCommand</param>
/// <param name="pageIndex">결과셋의 Page Index (0부터 시작)</param>
/// <param name="pageSize">결과셋 Paging 시의 Page Size</param>
/// <param name="parameters">DbCommand 실행시의 Parameter 정보</param>
/// <returns>Paging된 Persistent Object의 List</returns>
public static IPagingList <T> ExecuteInstance <T>(this IAdoRepository repository,
INameMapper nameMapper,
Action <IDataReader, T> additionalMapping,
DbCommand cmd,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters) where T : class
{
nameMapper.ShouldNotBeNull("nameMapper");
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug(
"IDataReader로부터 PersistentObject를 생성합니다... CommandText=[{0}], NameMapper=[{1}], pageIndex=[{2}], pageSize=[{3}], parameters=[{4}]",
cmd.CommandText, nameMapper, pageIndex, pageSize, parameters.CollectionToString());
}
var query = cmd.CommandText;
var firstResult = pageIndex * pageSize;
var maxResults = pageSize;
var totalItemCountTask = repository.CountAsync(query, parameters);
IList <T> instances;
using (var reader = repository.ExecuteReader(cmd, parameters))
instances = reader.Map <T>(ActivatorTool.CreateInstance <T>, nameMapper, firstResult, maxResults, additionalMapping);
var pagingList = new PagingList <T>(instances, pageIndex, pageSize, totalItemCountTask.Result);
if (IsDebugEnabled)
{
log.Debug("ExecuteReader를 수행해 엔티티로 매핑했습니다. pageIndex=[{0}], pageSize=[{1}], totalItemCount=[{2}]",
pageIndex, pageSize, totalItemCountTask.Result);
}
return(pagingList);
}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock<IClassFilter>();
_classFilter
.Stub(arg => arg.Matches(Arg<Type>.Is.Anything))
.WhenCalled(arg => arg.ReturnValue = (Type)arg.Arguments.First() == typeof(Endpoint))
.Return(false);
_idMapper = MockRepository.GenerateMock<IIdMapper>();
_idMapper
.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything))
.WhenCalled(arg => arg.ReturnValue = IdResult.IdMapped(Guid.NewGuid()))
.Return(null);
_nameMapper = MockRepository.GenerateMock<INameMapper>();
_nameMapper.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(NameResult.NameMapped("name"));
_resolvedRelativeUrlMapper = MockRepository.GenerateMock<IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative"));
_autoRouteCollection = new AutoRouteCollection(true)
.Assemblies(Assembly.GetExecutingAssembly())
.ClassFilters(_classFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper);
}
/// <summary>
/// <paramref name="oraCommand"/>를 실행하여, 결과 셋을 Persistent Object의 컬렉션으로 매핑합니다.
/// </summary>
/// <typeparam name="T">Persistent Object의 수형</typeparam>
/// <param name="oraDatabase">OracleProvider 인스턴스</param>
/// <param name="oraCommand">OracleCommand 인스턴스</param>
/// <param name="mapObjectFactory">PersistentObject 생성 Factory</param>
/// <param name="nameMapper">NameMapper 인스턴스</param>
/// <param name="firstResult">첫번째 결과 인덱스 (0부터 시작)</param>
/// <param name="maxResults">최대 결과 갯수</param>
/// <param name="additionalMapping">부가적인 매핑 작업을 수행할 델리게이트</param>
/// <param name="parameters">OracleCommand에 설정할 Parameter 정보</param>
/// <returns>DataReader로부터 인스턴싱된 Persistent Object의 컬렉션을 결과로 반환하는 Task</returns>
public static Task <IList <T> > ExecuteMapObject <T>(this EnterpriseLibrary.OracleDatabase oraDatabase,
OracleCommand oraCommand,
Func <T> mapObjectFactory,
INameMapper nameMapper,
int firstResult,
int maxResults,
Action <IDataReader, T> additionalMapping,
params IAdoParameter[] parameters)
{
oraCommand.ShouldNotBeNull("oraCommand");
return
(ExecuteReaderAsync(oraDatabase, oraCommand, parameters)
.ContinueWith(antecedent => {
using (var reader = antecedent.Result)
return AdoTool.Map <T>(reader,
mapObjectFactory,
nameMapper,
firstResult,
maxResults,
additionalMapping);
},
TaskContinuationOptions.ExecuteSynchronously));
}
/// <summary>
/// Merges all Windows event log source types from the specified assembly with the
/// creation data.
/// </summary>
/// <param name="assembly">Assembly to scan for perfromance counter types</param>
/// <param name="logNameMapper">Optional mapper for the log name</param>
/// <param name="sourceNameMapper">Optional mapper for the log source</param>
public void MergeSourcesFromAssembly(Assembly assembly, INameMapper logNameMapper = null,
INameMapper sourceNameMapper = null)
{
foreach (var type in assembly
.GetTypes()
.Where(type => type.IsSubclassOf(typeof(LogEventBase)) &&
type.GetCustomAttribute<SkipLogSourceInstallationAttribute>() == null))
{
Add(type, logNameMapper, sourceNameMapper);
}
}
/// <summary>
/// 지정된 DbCommand의 Parameter Name을 속성명으로 변경한다.
/// </summary>
/// <param name="command">실행할 DbCommand</param>
/// <param name="nameMapper">Command Parameter명을 Persistent Object의 속성명으로 매핑하는 Mapper</param>
/// <param name="propertyNamesToExclude">매핑에서 제외할 속성명</param>
/// <returns>name mapping table</returns>
/// <seealso cref="INameMapper"/>
/// <seealso cref="CapitalizeNameMapper"/>
/// <see cref="TrimNameMapper"/>
public static INameMap NameMapping(this DbCommand command, INameMapper nameMapper, params string[] propertyNamesToExclude) {
return Mapping(command, nameMapper.MapToPropertyName, propertyNamesToExclude);
}
/// <summary>
/// 지정된 DataTable의 컬럼명을 속성명으로 변경한다. 매퍼는 IoC를 통해 얻는다.
/// </summary>
/// <param name="table">Data source</param>
/// <param name="nameMapper">Parameter명을 속성명으로 매핑하는 Mapper</param>
/// <param name="propertyNamesToExclude">매핑에서 제외할 속성명</param>
/// <returns>name mapping table</returns>
/// <seealso cref="INameMapper"/>
/// <seealso cref="CapitalizeNameMapper"/>
/// <see cref="TrimNameMapper"/>
public static INameMap NameMapping(this DataTable table, INameMapper nameMapper, params string[] propertyNamesToExclude) {
return Mapping(table, nameMapper.MapToPropertyName, propertyNamesToExclude);
}
/// <summary>
/// 지정된 DataReader의 컬럼명을 속성명으로 변경한다. 매퍼는 IoC를 통해 얻는다.
/// </summary>
/// <param name="reader">instance of IDataReader</param>
/// <param name="nameMapper">Mapper of column name and property name</param>
/// <param name="propertyNamesToExclude">매핑에서 제외할 속성명</param>
/// <returns>name mapping table</returns>
/// <seealso cref="INameMapper"/>
/// <seealso cref="CapitalizeNameMapper"/>
/// <see cref="TrimNameMapper"/>
public static INameMap NameMapping(this IDataReader reader, INameMapper nameMapper, params string[] propertyNamesToExclude) {
return Mapping(reader, nameMapper.MapToPropertyName, propertyNamesToExclude);
}
/// <summary>
/// <paramref name="reader"/>를 읽어, <see cref="ResultRow"/>의 컬렉션인 <see cref="ResultSet"/>을 빌드합니다.
/// </summary>
/// <param name="reader">DataReader</param>
/// <param name="nameMapper">컬럼명을 속성명으로 매핑해주는 매퍼입니다.</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작)</param>
/// <param name="maxResults">최대 레코드 수</param>
/// <returns><see cref="ResultSet"/> 인스턴스</returns>
public static ResultSet CreateResultSet(this IDataReader reader, INameMapper nameMapper, int firstResult, int maxResults) {
reader.ShouldNotBeNull("reader");
if(nameMapper == null)
nameMapper = new SameNameMapper();
if(IsDebugEnabled)
log.Debug("IDataReader로부터 정보를 읽어 ResultRow들을 만들어 ResultSet 으로 빌드합니다...");
var resultSet = new ResultSet();
while(firstResult-- > 0) {
if(reader.Read() == false)
return resultSet;
}
if(maxResults <= 0)
maxResults = int.MaxValue;
resultSet.FieldNames = reader.GetFieldNames();
var rowIndex = 0;
while(reader.Read() && rowIndex++ < maxResults) {
var row = new ResultRow();
foreach(var fieldName in resultSet.FieldNames)
row.Add(nameMapper.MapToPropertyName(fieldName), reader.AsValue(fieldName));
resultSet.Add(row);
}
if(IsDebugEnabled)
log.Debug("IDataReader로부터 정보를 읽어 ResultSet을 빌드했습니다!!! Row Count=[{0}]", resultSet.Count);
return resultSet;
}
protected NorthwindDataContext(System.Data.Common.DbConnection connection, INameMapper nameMapper) :
base(connection, nameMapper)
{
OnCreated();
}
private DistinctColumnExtractor(INameMapper mapper)
{
_Mapper = mapper;
}
public DataCommandServiceImpl(IAdoRepository adoRepository, INameMapper nameMapper) : base(adoRepository, nameMapper) {}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock<IClassFilter>();
_classFilter
.Stub(arg => arg.Matches(Arg<Type>.Is.Anything))
.WhenCalled(arg => arg.ReturnValue = (Type)arg.Arguments.First() == typeof(Endpoint))
.Return(false);
_idMapper1 = MockRepository.GenerateMock<IIdMapper>();
_idMapper1.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(IdResult.IdMapped(Guid.Parse("1dffe3ee-1ade-4aa2-835a-9cb91b7e31c4")));
_idMapper2 = MockRepository.GenerateMock<IIdMapper>();
_idMapper2.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(IdResult.IdMapped(Guid.Parse("493e725c-cbc1-4ea4-b6d1-350018d4542d")));
_nameMapper = MockRepository.GenerateMock<INameMapper>();
_nameMapper.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(NameResult.NameMapped("name"));
_resolvedRelativeUrlMapper = MockRepository.GenerateMock<IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative"));
_responseMapper = MockRepository.GenerateMock<IResponseMapper>();
_autoRouteCollection = new AutoRouteCollection()
.Assemblies(Assembly.GetExecutingAssembly())
.ClassFilters(_classFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper1)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper)
.ResponseMapper(_responseMapper);
_routes = _autoRouteCollection.GenerateRouteCollection().ToArray();
}
public AsyncDataCommandServiceImpl(IAdoRepository repository, INameMapper nameMapper) : base(repository, nameMapper) {}
public void SetUp()
{
_classFilter = MockRepository.GenerateMock<IClassFilter>();
_classFilter
.Stub(arg => arg.Matches(Arg<Type>.Is.Anything))
.WhenCalled(arg => arg.ReturnValue = (Type)arg.Arguments.First() == typeof(Endpoint))
.Return(false);
_idMapper = MockRepository.GenerateMock<IIdMapper>();
_idMapper.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(IdResult.IdMapped(Guid.NewGuid()));
_nameMapper = MockRepository.GenerateMock<INameMapper>();
_nameMapper.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(NameResult.NameMapped("name"));
_resolvedRelativeUrlMapper = MockRepository.GenerateMock<IResolvedRelativeUrlMapper>();
_resolvedRelativeUrlMapper.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything)).Return(ResolvedRelativeUrlResult.ResolvedRelativeUrlMapped("relative"));
_responseMapper = MockRepository.GenerateMock<IResponseMapper>();
_restrictionMapper1 = MockRepository.GenerateMock<IRestrictionMapper>();
_restrictionMapper1
.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything, Arg<Route.Routing.Route>.Is.Anything, Arg<IContainer>.Is.Anything))
.WhenCalled(arg => ((Route.Routing.Route)arg.Arguments.Skip(2).First()).RestrictByMethods("GET"));
_restrictionMapper2 = MockRepository.GenerateMock<IRestrictionMapper>();
_restrictionMapper2
.Stub(arg => arg.Map(Arg<Type>.Is.Anything, Arg<MethodInfo>.Is.Anything, Arg<Route.Routing.Route>.Is.Anything, Arg<IContainer>.Is.Anything))
.WhenCalled(arg => ((Route.Routing.Route)arg.Arguments.Skip(2).First()).RestrictByMethods("POST"));
_autoRouteCollection = new AutoRouteCollection()
.Assemblies(Assembly.GetExecutingAssembly())
.ClassFilters(_classFilter)
.NameMappers(_nameMapper)
.IdMappers(_idMapper)
.ResolvedRelativeUrlMappers(_resolvedRelativeUrlMapper)
.ResponseMapper(_responseMapper)
.RestrictionMappers(_restrictionMapper1, _restrictionMapper2);
}
/// <summary>
/// <paramref name="reader"/>를 읽어, <see cref="ResultRow"/>의 컬렉션인 <see cref="ResultSet"/>을 빌드합니다.
/// </summary>
/// <param name="reader">DataReader</param>
/// <param name="nameMapper">컬럼명을 속성명으로 매핑해주는 매퍼입니다.</param>
/// <returns><see cref="ResultSet"/> 인스턴스</returns>
public static ResultSet CreateResultSet(this IDataReader reader, INameMapper nameMapper) {
return CreateResultSet(reader, nameMapper, 0, int.MaxValue);
}
public static Expression Bind(Expression expr, INameMapper mapper)
{
var qt = new QueryBinder(mapper);
expr = qt.Visit(expr);
return expr;
}
/// <summary>
/// <paramref name="reader"/>를 읽어, <see cref="ResultRow"/>를 빌드합니다.
/// </summary>
/// <param name="reader">DataReader</param>
/// <param name="fieldNames">컬럼명 리스트</param>
/// <param name="nameMapper">컬럼명을 속성명으로 매핑해주는 매퍼입니다.</param>
/// <returns></returns>
internal static ResultRow CreateResultRow(this IDataReader reader, IList<string> fieldNames, INameMapper nameMapper) {
Guard.Assert(reader.IsClosed == false, "reader 가 닫혀있습니다.");
var row = new ResultRow();
foreach(var fieldName in fieldNames)
row.Add(nameMapper.MapToPropertyName(fieldName), reader.AsValue(fieldName));
return row;
}
private QueryBinder(INameMapper mapper)
{
this.mapper = mapper;
}
