protected BaseApiController(IRepository <TEntity> repository, IApiHelper apiHelper,
IEntityConverter <TEntity, TGetModel, TGetSingleModel, TAddModel, TUpdateModel> entityConverter)
{
EntityRepository = repository ?? throw new ArgumentNullException(nameof(repository));
ApiHelper = apiHelper ?? throw new ArgumentNullException(nameof(apiHelper));
EntityConverter = entityConverter ?? throw new ArgumentNullException(nameof(entityConverter));
}
public LicenseController(IFossLockService<License> service, IEntityConverter<License, LicenseViewModel> converter,
IFossLockService<Customer> customerService)
{
this.service = service;
this.converter = converter;
this.customerService = customerService;
}
/// <summary>
/// 将 DataRow 转换为实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataItem">包含数据的 DataRow</param>
/// <param name="converter">实体转换器</param>
/// <returns>实体</returns>
public static T ToEntity <T>(this DataRow dataItem, IEntityConverter <T> converter)
{
if (dataItem == null)
{
if (typeof(T).IsValueType)
{
throw new ArgumentNullException("dataItem");
}
else
{
return(default(T));//等同于return null
}
}
if (dataItem.Table.Columns.Count == 1)
{
var value = dataItem[0];
if (value is T)
{
return((T)value);
}
}
var entityConverter = converter ?? EntityConvert <T> .GetConverter();
return(entityConverter.Convert(dataItem));
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
if (_Tran != null)
{
_Tran.Dispose();
}
if (_Conn != null)
{
_Conn.Close();
_Conn.Dispose();
}
}
_PC = null;
_SC = null;
_EC = null;
_Tran = null;
_Conn = null;
disposedValue = true;
}
}
public PersonService(
PersonRepository personRepository,
IEntityConverter <Domain.Person, Person> personConverter)
{
_personRepository = personRepository;
_personConverter = personConverter;
}
public SearchController(
SearchService searchService,
IEntityConverter <Domain.Person, Contracts.Person> personConverter)
{
_searchService = searchService;
_personConverter = personConverter;
}
public TestDatabaseService(IDatabase database,
IDatabaseTable <TestEnum, ITestDomain, TestEntity> testDatabaseTable,
ITestDatabaseValidateService testDatabaseValidateService,
IEntityConverter <TestEnum, ITestDomain, TestEntity> testEntityConverter)
: base(database, testDatabaseTable, testDatabaseValidateService, testEntityConverter)
{
}
public LicenseController(IFossLockService <License> service, IEntityConverter <License, LicenseViewModel> converter,
IFossLockService <Customer> customerService)
{
this.service = service;
this.converter = converter;
this.customerService = customerService;
}
public AzureTableClient(CloudTable table, IEntityConverter <TEntity> converter, IRowIndexManager <TEntity> rowIndexManager)
{
TypeChecker.EnsureEntityTypesSupported(EntityType);
_table = table;
_converter = converter;
_rowIndexManager = rowIndexManager;
}
public override void Apply(IEntityConverterBuilder <TEntity, TSchema> builder)
{
IEntityConverter <TEntityValue> entityConverter = builder.GetEntityConverter <TEntityValue>();
var mapper = new ValueEntityProperty <TEntity, TEntityValue>(builder.ImplementationType, Property.Name, Position, x => Factory(x, entityConverter));
builder.Add(mapper);
}
public override void Apply(IEntityConverterBuilder <TEntity, TSchema> builder)
{
IEntityConverter <TEntityValue> entityConverter = builder.GetEntityConverter <TEntityValue>();
var property = new ValueListEntityPropertyConverter <TEntity, TEntityValue>(builder.ImplementationType, Property.Name, Position,
x => new EntityValueList <TEntityValue>(x, entityConverter), SliceProvider);
builder.Add(property);
}
public FlightService(
FlightRepository flightRepository,
BookingRepository bookingRepository,
IEntityConverter <Domain.Person, Person> personConverter)
{
_flightRepository = flightRepository;
_bookingRepository = bookingRepository;
_personConverter = personConverter;
}
protected DatabaseService(IDatabase database,
IDatabaseTable <TId, TDomain, TEntityOut> dataTable,
IDatabaseValidateService <TId, TDomain> databaseValidateService,
IEntityConverter <TId, TDomain, TEntityOut> mainEntityConverter)
{
_database = database;
_dataTable = dataTable;
_databaseValidateService = databaseValidateService;
_mainEntityConverter = mainEntityConverter;
}
public void Add <T>(IEntityConverter <T> converter)
where T : TSchema
{
_entityConverters[converter.EntityInfo.EntityType] = converter;
if (converter.EntityInfo.EntitySelector != null)
{
_entitySelectorFactory.Add(converter.EntityInfo);
}
}
public void RegisterConverter(IEntityConverter <TInput, TOutput> converter)
{
var converterType = converter.GetType();
if (_converters.ContainsKey(converterType))
{
throw new NotSupportedException($"This multi type converter already contains a converter for type {converterType}. Only one is supported.");
}
_converters.Add(converterType, converter);
}
public BookingService(
BookingRepository bookingRepository,
FlightService flightService,
PersonService personService,
IEntityConverter<Domain.Booking, Booking> bookingConverter)
{
_bookingRepository = bookingRepository;
_flightService = flightService;
_personService = personService;
_bookingConverter = bookingConverter;
}
public override void Apply(IEntityConverterBuilder <TEntity, TSchema> builder)
{
IEntityConverter <TEntityValue> entityConverter = builder.GetEntityConverter <TEntityValue>();
Value <TEntityValue> Factory(TextSlice slice)
{
return(new ConvertValue <TEntityValue>(slice, Position, entityConverter));
}
var mapper = new ValueEntityPropertyConverter <TEntity, TEntityValue>(builder.ImplementationType, Property.Name, Factory);
builder.Add(mapper);
}
public void SetUp()
{
converter = new CustomerConverter();
serviceMocker = new Mock <IFossLockService <Customer> >();
service = serviceMocker.Object;
controllerMocker = new Mock <PrimaryEntityCrudController <Customer, CustomerViewModel> >(
service, converter)
{
CallBase = true
};
controller = controllerMocker.Object;
}
public ResourcesController(IMembershipService membershipService,
IBlobStore blobStore, IViewRepository<FileEditModelSync> viewRepository,
IViewModelBuilder<FileEditModelSync> modelBuilder, IEntityConverter<DocumentSubcategory, CategoryEditModel> catConverter,
IModelConverter<SharedDocument, FileEditModelSync> fileModelConverter, IViewRepository<UserProcedurePatientDocViewModel> patientDocViewRepository,
IFileService fileService, IUnitOfWork unitOfWork) : base(membershipService, blobStore)
{
_viewRepository = viewRepository;
_modelBuilder = modelBuilder;
_catConverter = catConverter;
_fileModelConverter = fileModelConverter;
_patientDocViewRepository = patientDocViewRepository;
_fileService = fileService;
_unitOfWork = unitOfWork;
}
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_Reader.Close();
_Reader.Dispose();
}
_Reader = null;
_EC = null;
_SC = null;
disposedValue = true;
}
}
public NewsManager(IApiHandler apiHandler,
IDbGetter dbGetter,
IDbSaver dbSaver,
ITagService tagService,
IEntityConverter entityConverter,
IVectorModelBuilder vmBuilder)
{
this.apiHandler = apiHandler;
this.dbGetter = dbGetter;
this.dbSaver = dbSaver;
this.tagService = tagService;
this.entityConverter = entityConverter;
this.stopWordsFilter = new StopWordsFilter();
this.porterFilter = new PorterStemmerFilter();
this.vectorModelBuilder = vmBuilder;
}
/// <summary>
/// 将 DataRow 转换为实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataItem">包含数据的 DataRow</param>
/// <param name="converter">实体转换器</param>
/// <returns>实体</returns>
public static T ToEntity <T>(this DataRow dataItem, IEntityConverter <T> converter) where T : new()
{
if (dataItem == null)
{
if (typeof(T).IsValueType)
{
throw new ArgumentNullException("dataItem");
}
else
{
return(default(T));//等同于return null
}
}
if (dataItem.Table.Columns.Count == 1)
{
var value = dataItem[0];
if (value is T)
{
return((T)value);
}
}
var entityConverter = converter ?? EntityConverterCache <T> .GetConverter();
var entity = new T();
if (entityConverter.NeedPreconversion)
{
var method = CreateEntityConvertMethod <T>();
method(dataItem, entity);
}
entityConverter.Convert(dataItem, entity);
return(entity);
}
static EntityConverterCache()
{
var type = typeof(T);
var attribute = type.GetCustomAttributes(typeof(EntityConvertAttribute), false).OfType <EntityConvertAttribute>().FirstOrDefault();
if (attribute != null)
{
createConverter = () => attribute.CreateConverter <T>(); //缓存创建实例的方法
}
else
{
createConverter = () => new DefaultEntityConverter <T>();
}
var instance = createConverter();
if (instance.IsReusable)
{
converterInstacne = instance; //缓存可复用的实例
}
}
/// <summary>
/// 查询数据库并将第一个结果集填充实体类型
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="query">要执行的查询</param>
/// <param name="token">取消指示</param>
/// <param name="converter">实体转换器</param>
/// <returns>实体集</returns>
public async static Task <T[]> ExecuteEntitiesAsync <T>(this IAsyncDbExecutableQuery query, CancellationToken token, IEntityConverter <T> converter) where T : new()
{
var data = await query.ExecuteDataTableAsync(token);
return(data.GetRows().Select(dataItem => dataItem.ToEntity <T>(converter)).ToArray());
}
/// <summary>
/// 查询数据库并将第一个结果集填充实体类型
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="query">要执行的查询</param>
/// <param name="converter">实体转换器</param>
/// <returns>实体集</returns>
public static Task <T[]> ExecuteEntitiesAsync <T>(this IAsyncDbExecutableQuery query, IEntityConverter <T> converter) where T : new()
{
return(ExecuteEntitiesAsync(query, CancellationToken.None, converter));
}
/// <summary>
/// 查询数据库并将第一个结果集填充实体类型
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="query">要执行的查询</param>
/// <param name="converter">实体转换器</param>
/// <returns>实体集</returns>
public static T[] ExecuteEntities <T>(this IDbExecutableQuery query, IEntityConverter <T> converter) where T : new()
{
var data = query.ExecuteDataTable();
return(data.GetRows().Select(dataItem => dataItem.ToEntity(converter)).ToArray());
}
/// <summary>
/// 将 DataRow 转换为实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="dataItem">包含数据的 DataRow</param>
/// <param name="converter">实体转换器</param>
/// <returns>实体</returns>
public static T ToEntity <T>(this DataRow dataItem, IEntityConverter <T> converter = null) where T : new()
{
if (dataItem == null)
{
if (typeof(T).IsValueType)
{
throw new ArgumentNullException("dataItem");
}
else
{
return(default(T));//等同于return null
}
}
if (dataItem.Table.Columns.Count == 1)
{
var value = dataItem[0];
if (value is T)
{
return((T)value);
}
}
var convertType = converter ?? ConvertTypeCache <T> .Converter;
if (convertType == null)
{
var type = typeof(T);
var attribute = type.GetCustomAttributes(typeof(EntityConvertAttribute), false).OfType <EntityConvertAttribute>().FirstOrDefault();
if (attribute != null)
{
convertType = attribute.CreateConverter <T>();
}
else
{
convertType = new DefaultEntityConverter <T>();
}
if (convertType.IsReusable)
{
ConvertTypeCache <T> .Converter = convertType;
}
}
var entity = new T();
if (convertType.NeedPreconversion)
{
var method = CreateEntityConvertMethod <T>();
method(dataItem, entity);
}
convertType.Convert(dataItem, entity);
return(entity);
}
/// <summary>
/// 查询数据库并将结果首行填充实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="query">要执行的查询</param>
/// <param name="token">取消指示</param>
/// <param name="converter">实体转换方法</param>
/// <returns>实体</returns>
public async static Task <T> ExecuteEntityAsync <T>(this IAsyncDbExecutableQuery query, CancellationToken token, IEntityConverter <T> converter) where T : new()
{
var dataItem = await query.ExecuteFirstRowAsync(token);
return(dataItem.ToEntity <T>(converter));
}
/// <summary>
/// 查询数据库并将结果首行填充实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="query">要执行的查询</param>
/// <param name="converter">实体转换方法</param>
/// <returns>实体</returns>
public static T ExecuteEntity <T>(this IDbExecutableQuery query, IEntityConverter <T> converter) where T : new()
{
var dataItem = query.ExecuteFirstRow();
return(dataItem.ToEntity <T>(converter));
}
public void SetUp()
{
converter = new CustomerConverter();
serviceMocker = new Mock<IFossLockService<Customer>>();
service = serviceMocker.Object;
controllerMocker = new Mock<PrimaryEntityCrudController<Customer, CustomerViewModel>>(
service, converter)
{
CallBase = true
};
controller = controllerMocker.Object;
}
public DataService(Assembly assembly)
{
_assembly = assembly;
_entityConverter = new EntityConverter(assembly, new PropertyHelper());
_objectConverter = new ObjectConverter();
}
public SRPokemonInfoRepository(IRepository<Pokemon> pokemonRepository,
IEntityConverter converter)
{
_base = pokemonRepository;
_converter = converter;
}
public PostgreSQLDataCommand(IParamConverter pc, IScalarConverter sc, IEntityConverter ec) : base(pc, sc, ec)
{
}
/// <summary>
/// 查询数据库并将结果首行填充实体
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="query">要执行的查询</param>
/// <param name="token">取消指示</param>
/// <param name="converter">实体转换方法</param>
/// <returns>实体</returns>
public async static Task <T> ExecuteEntityAsync <T>(this IDbExecutable query, IEntityConverter <T> converter, CancellationToken token = default(CancellationToken))
{
var dataItem = await query.ExecuteFirstRowAsync(token);
return(dataItem.ToEntity <T>(converter));
}
