public DataRepository(IDatabaseGateway databaseGateway, IDataRowMapper <T> dataRowMapper)
{
Guard.AgainstNull(databaseGateway, "databaseGateway");
Guard.AgainstNull(dataRowMapper, "dataRowMapper");
_databaseGateway = databaseGateway;
_dataRowMapper = dataRowMapper;
}
public static IEnumerable <MappedRow <T> > MappedRowsUsing <T>(this IEnumerable <DataRow> rows,
IDataRowMapper <T> mapper) where T : class
{
var result = new List <MappedRow <T> >();
foreach (var row in rows)
{
result.Add(mapper.Map(row));
}
return(result);
}
public MatricesController(IServiceBus bus, IDatabaseContextFactory databaseContextFactory,
IDataRowMapper dataRowMapper, IMatrixQuery matrixQuery)
{
Guard.AgainstNull(bus, nameof(bus));
Guard.AgainstNull(databaseContextFactory, nameof(databaseContextFactory));
Guard.AgainstNull(dataRowMapper, nameof(dataRowMapper));
Guard.AgainstNull(matrixQuery, nameof(matrixQuery));
_bus = bus;
_databaseContextFactory = databaseContextFactory;
_dataRowMapper = dataRowMapper;
_matrixQuery = matrixQuery;
}
public FormulasController(IServiceBus bus, IDatabaseContextFactory databaseContextFactory,
IDataRowMapper dataRowMapper, IFormulaQuery formulaQuery)
{
Guard.AgainstNull(bus, nameof(bus));
Guard.AgainstNull(databaseContextFactory, nameof(databaseContextFactory));
Guard.AgainstNull(dataRowMapper, nameof(dataRowMapper));
Guard.AgainstNull(formulaQuery, nameof(formulaQuery));
_bus = bus;
_databaseContextFactory = databaseContextFactory;
_dataRowMapper = dataRowMapper;
_formulaQuery = formulaQuery;
}
public ArgumentsController(IServiceBus bus, IDatabaseContextFactory databaseContextFactory,
IDataRowMapper dataRowMapper, IArgumentQuery argumentQuery)
{
Guard.AgainstNull(bus, nameof(bus));
Guard.AgainstNull(databaseContextFactory, nameof(databaseContextFactory));
Guard.AgainstNull(dataRowMapper, nameof(dataRowMapper));
Guard.AgainstNull(argumentQuery, nameof(argumentQuery));
_bus = bus;
_databaseContextFactory = databaseContextFactory;
_dataRowMapper = dataRowMapper;
_argumentQuery = argumentQuery;
}
public OrderProcessRepository(IDatabaseGateway databaseGateway, IOrderProcessQueryFactory queryFactory, IDataRowMapper <OrderProcess> orderProcessMapper, IDataRowMapper <OrderProcessItem> orderProcessItemMapper, IDataRowMapper <OrderProcessStatus> orderProcessStatusMapper)
{
Guard.AgainstNull(databaseGateway, "databaseGateway");
Guard.AgainstNull(queryFactory, "queryFactory");
Guard.AgainstNull(orderProcessMapper, "orderProcessMapper");
Guard.AgainstNull(orderProcessItemMapper, "orderProcessItemMapper");
Guard.AgainstNull(orderProcessStatusMapper, "orderProcessStatusMapper");
_databaseGateway = databaseGateway;
_queryFactory = queryFactory;
_orderProcessMapper = orderProcessMapper;
_orderProcessItemMapper = orderProcessItemMapper;
_orderProcessStatusMapper = orderProcessStatusMapper;
}
public TestsController(IServiceBus bus, IDatabaseContextFactory databaseContextFactory,
IDataRowMapper dataRowMapper, ITestRepository testRepository, ITestQuery testQuery,
IExecutionService executionService, IValueComparer valueComparer)
{
Guard.AgainstNull(bus, nameof(bus));
Guard.AgainstNull(databaseContextFactory, nameof(databaseContextFactory));
Guard.AgainstNull(dataRowMapper, nameof(dataRowMapper));
Guard.AgainstNull(testRepository, nameof(testRepository));
Guard.AgainstNull(testQuery, nameof(testQuery));
Guard.AgainstNull(executionService, nameof(executionService));
Guard.AgainstNull(valueComparer, nameof(valueComparer));
_bus = bus;
_databaseContextFactory = databaseContextFactory;
_dataRowMapper = dataRowMapper;
_testRepository = testRepository;
_testQuery = testQuery;
_executionService = executionService;
_valueComparer = valueComparer;
}
IEnumerable <T> IDatabase.ExecuteEnumerable <T>(IQueryCommand queryCommand, IDataSegment segment, ParameterCollection parameters, IDataRowMapper <T> rowMapper)
{
return(database.ExecuteEnumerable(queryCommand, segment, parameters, rowMapper));
}
Task <IEnumerable <T> > IDatabase.ExecuteEnumerableAsync <T>(IQueryCommand queryCommand, IDataSegment segment, ParameterCollection parameters, IDataRowMapper <T> rowMapper, CancellationToken cancellationToken)
{
return(database.ExecuteEnumerableAsync <T>(queryCommand, segment, parameters, rowMapper, cancellationToken));
}
public DataTableMapper(IDataColumnMapper <T> dataColumnMapper, IDataRowMapper <T> dataRowMapper)
{
DataColumnMapper = dataColumnMapper;
DataRowMapper = dataRowMapper;
}
/// <summary>
/// 异步执行查询文本并将结果以一个 <see cref="IEnumerable{T}"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <param name="cancellationToken">取消操作的通知。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public async virtual Task <IEnumerable <T> > ExecuteEnumerableAsync <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null, CancellationToken cancellationToken = default)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
rowMapper = rowMapper ?? RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
var reader = await ExecuteReaderAsync(queryCommand, segment, parameters, cancellationToken);
return(new AsyncEnumerable <T>(this, reader, rowMapper));
}
/// <summary>
/// 执行查询文本并将结果以一个 <see cref="IEnumerable{T}"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public virtual IEnumerable <T> ExecuteEnumerable <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
rowMapper = rowMapper ?? RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
using (var reader = ExecuteReader(queryCommand, segment, parameters))
{
while (reader.Read())
{
yield return(rowMapper.Map(this, reader));
}
}
}
public AsyncEnumerator(IDatabase database, IDataReader reader, IDataRowMapper <T> rowMapper)
{
this.database = database;
this.reader = reader;
this.rowMapper = rowMapper;
}
public AsyncEnumerable(IDatabase database, IDataReader reader, IDataRowMapper <T> rowMapper)
{
this.enumerator = new AsyncEnumerator <T>(database, reader, rowMapper);
}
/// <summary>
/// 异步的，执行查询文本并将结果以一个 <see cref="IEnumerable{T}"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <param name="cancellationToken">取消操作的通知。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public async virtual IAsyncEnumerable <T> ExecuteEnumerableAsync <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null, CancellationToken cancellationToken = default)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
rowMapper = rowMapper ?? RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
using (var reader = (DbDataReader)(await ExecuteReaderAsync(queryCommand, segment, parameters, cancellationToken)))
{
while (await reader.ReadAsync(cancellationToken))
{
yield return(rowMapper.Map(this, reader));
}
}
}
/// <summary>
/// 异步的，执行查询文本并将结果以一个 <see cref="IEnumerable{T}"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <param name="cancellationToken">取消操作的通知。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public async virtual Task <IEnumerable <T> > ExecuteEnumerableAsync <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null, CancellationToken cancellationToken = default)
{
Guard.ArgumentNull(queryCommand, nameof(queryCommand));
cancellationToken.ThrowIfCancellationRequested();
var result = new List <T>();
rowMapper ??= RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
using var reader = (InternalDataReader) await ExecuteReaderAsync(queryCommand, segment, parameters, CommandBehavior.Default, cancellationToken);
while (await reader.ReadAsync(cancellationToken))
{
result.Add(rowMapper.Map(this, reader));
}
return(result);
}
/// <summary>
/// 异步执行查询文本并将结果以一个 <see cref="IEnumerable<T>"/> 的序列返回。
/// </summary>
/// <typeparam name="T">查询对象类型。</typeparam>
/// <param name="queryCommand">查询命令。</param>
/// <param name="segment">数据分段对象。</param>
/// <param name="parameters">查询参数集合。</param>
/// <param name="rowMapper">数据行映射器。</param>
/// <returns>一个 <typeparamref name="T"/> 类型的对象的枚举器。</returns>
public async virtual Task <IEnumerable <T> > ExecuteEnumerableAsync <T>(IQueryCommand queryCommand, IDataSegment segment = null, ParameterCollection parameters = null, IDataRowMapper <T> rowMapper = null)
{
Guard.ArgumentNull(queryCommand, "queryCommand");
var reader = ExecuteReaderAsync(queryCommand, segment, parameters);
return(await new Task <IEnumerable <T> >(() =>
{
var list = new List <T>();
rowMapper = rowMapper ?? RowMapperFactory.CreateRowMapper <T>();
rowMapper.RecordWrapper = Provider.GetService <IRecordWrapper>();
return new List <T>(new AsyncEnumerable <T>(reader.Result, rowMapper));
}));
}
