/// <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();
}
}
}
