/// <summary> /// execute Raw SQL queries: Non-model types /// https://github.com/aspnet/EntityFrameworkCore/issues/1862 /// </summary> public static List <T> SqlQuery <T>(this DbContext context, string query, ILogger logger, params SqlParameter[] sqlParams) { using (var command = context.Database.GetDbConnection().CreateCommand()) { command.CommandText = query; command.CommandType = CommandType.Text; if (sqlParams != null) { command.Parameters.AddRange(sqlParams); } context.Database.OpenConnection(); using (var result = command.ExecuteReader()) { var sw = new Stopwatch(); sw.Start(); var list = new List <T>(); var mapper = new DataReaderMapper <T>(result); while (result.Read()) { list.Add(mapper.MapFrom(result)); } sw.Stop(); logger?.LogInformation($"Executed ({sw.ElapsedMilliseconds}ms)"); logger?.LogInformation($"{query}"); return(list); } } }
public static IEnumerable <T> Execute <T>(this IBaitkmDbContext context, string query, params SqlParameter[] sqlParams) where T : class, IStoredProcedureResponse, new() { using (var command = context.Database.GetDbConnection().CreateCommand()) { command.CommandText = query; command.CommandType = CommandType.StoredProcedure; command.CommandTimeout = 60; if (sqlParams != null) { command.Parameters.AddRange(sqlParams); } using (context.Database.OpenConnectionAsync()) { using (var reader = command.ExecuteReader()) { if (!reader.Any()) { yield break; } var mapper = new DataReaderMapper <T>(reader); do { yield return(mapper.MapFrom(reader)); } while (reader.Read()); } } } }
public Enumerator(IDataReader reader, DataReaderMapper <T> mapper, Action <T> post_map) { mapper_ = mapper; reader_ = reader; post_map_ = post_map; }
public static async Task <IEnumerable <T> > FromSqlAsync <T>(this DbContext context, string query, List <SqlParameter> sqlParams) { using (var command = context.Database.GetDbConnection().CreateCommand()) { command.CommandText = query; command.CommandType = CommandType.Text; if (sqlParams != null) { command.Parameters.AddRange(sqlParams.ToArray()); } await context.Database.OpenConnectionAsync(); using (var result = await command.ExecuteReaderAsync()) { var list = new List <T>(); var mapper = new DataReaderMapper <T>(result); while (await result.ReadAsync()) { list.Add(mapper.MapFrom(result)); } return(list); } } }
public static DataReaderMapper <DataTableReader> BuildAndConfigureFor <TDto>(Dictionary <Type, Expression> typeConvertors = null) where TDto : class, new() { var mapper = new DataReaderMapper <DataTableReader>(typeConvertors); mapper.Configure <TDto>(); return(mapper); }
/// <summary> /// Builds a dynamic type that implements the /// <see cref="IDataReaderMapper{T}"/> interface. /// </summary> /// <returns> /// A instance of the dynamically created class. /// </returns> /// <remarks> /// <see cref="Build"/> will create a dynamic type that implements the /// <see cref="IDataReaderMapper{T}"/> for the type /// <typeparamref source="T"/> only if the type does not exists already. If /// the type already exists <see cref="Build"/> will only create an /// instance of that class. /// <para> /// If the dynamic class already exists the mapping defined for the first /// build will be used. /// </para> /// <para> /// If you need to map the <typeparamref name="T"/> using distinct ways, /// you should create a <see cref="DataReaderMapperBuilder{T}"/> that /// uses distinct prefixes. /// </para> /// </remarks> /// <seealso cref="DataReaderMapperBuilder{T}"/> public IDataReaderMapper <T> Build() { DataReaderMapper <T> mapper = (DataReaderMapper <T>) Activator.CreateInstance(GetDynamicType(type_t_type_name_)); if (factory_ != null) { mapper.loader_ = factory_; } return(mapper); }
public void Setup() { var typeConvertors = TypeConvertors.DefaultConvertors; typeConvertors.Add(typeof(bool), (Expression <Func <object, bool> >)(o => o.ToString() == "1")); // common use case is that db store flags as varchar data type typeConvertors.Add(typeof(List <Order>), (Expression <Func <object, List <Order> > >)(o => o.ToString().Split(',').Select(x => new Order { Id = x }).ToList())); // lets say you also need to parse some data from some weird format _sut = new DataReaderMapper <DataTableReader>(typeConvertors); _sut.Configure <RichDto>(); }
/// <summary> /// IDataReader转化为实体列表 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="reader"></param> /// <returns></returns> public virtual List <T> DataReaderToEntityList <T>(IDataReader reader) { List <T> entityList = null; if (reader == null) { return(entityList); } entityList = new List <T>(); DataReaderMapper <T> readBuild = DataReaderMapper <T> .GetInstance(reader); while (reader.Read()) { entityList.Add(readBuild.Map(reader)); } return(entityList); }
public List <PlaceModel> GetPlacesByCity(string cityName) { try { List <PlaceModel> placeList = new List <PlaceModel>(); List <SqlParameter> sqlParamsList = new List <SqlParameter>() { new SqlParameter("@city ", cityName) }; var placesList = placeRepository.ExecuteStoredProcedure("usp_GetPlaceListByCity", sqlParamsList); if (placesList != null) { using (placesList) { placeList = DataReaderMapper.MapToList <PlaceModel>(placesList); } //foreach (var data in placesList) //{ // PlaceModel placeModel = new PlaceModel(); // placeModel.Name = data.Name; // placeModel.PlaceDescription = data.PlaceDescription; // placeModel.Address = data.Address; // placeModel.ImageUrl = data.ImageUrl; // placeModel.Tips = data.Tips; // placeModel.Distance = data.Distance; // placeModel.BestTimeToVisit = data.BestTimeToVisit; // placeModel.Latitude = data.Latitude; // placeModel.Longitude = data.Longitude; // placeList.Add(placeModel); //} } return(placeList); } catch (Exception ex) { throw new Exception("Error while get all place list due to:" + ex); } }
public void BenchmarkMostlyReadDictionary(int readsPerWrite) { Benchmark.Go("MostlyReadDictionary", iterations => { var methods = new MostlyReadDictionary <DataReaderMapper.MetaData, Delegate>(); while (iterations > 0) { var reader = CreateDataReader("extra" + iterations); var columns = DataReaderMapper.CreateColumnList(reader); GC.KeepAlive(methods.GetOrAdd(new DataReaderMapper.MetaData(typeof(Target), columns), Target.Create)); for (int i = 0; i < readsPerWrite; i++) { if (--iterations <= 0) { break; } GC.KeepAlive(methods.GetOrAdd(new DataReaderMapper.MetaData(typeof(Target), columns), Target.Create)); } } }); }
protected IEnumerable <T> ExecuteEnumerable <T>(DbManager db, Type objectType, bool disposeDbManager) { try { using (IDataReader rd = db.ExecuteReader()) { if (rd.Read()) { ObjectMapper dest = MappingSchema.GetObjectMapper(objectType); DataReaderMapper source = MappingSchema.CreateDataReaderMapper(rd); InitContext ctx = new InitContext(); ctx.MappingSchema = MappingSchema; ctx.ObjectMapper = dest; ctx.DataSource = source; ctx.SourceObject = rd; int[] index = MappingSchema.GetIndex(source, dest); IValueMapper[] mappers = ctx.MappingSchema.GetValueMappers(source, dest, index); do { T destObject = (T)dest.CreateInstance(ctx); if (ctx.StopMapping) { yield return(destObject); } ISupportMapping smDest = destObject as ISupportMapping; if (smDest != null) { smDest.BeginMapping(ctx); if (ctx.StopMapping) { yield return(destObject); } } MappingSchema.MapInternal(source, rd, dest, destObject, index, mappers); if (smDest != null) { smDest.EndMapping(ctx); } yield return(destObject); } while (rd.Read()); } } } finally { if (disposeDbManager) { db.Dispose(); } } }