/// <summary>
/// Builds a deserializer.
/// </summary>
/// <param name="resultType">Type of the result.</param>
/// <param name="mappings">The mappings.</param>
/// <returns>IEnumerable<TResult>.</returns>
public IDeserializer BuildDeserializer(Type resultType, IMappingExport mappings)
{
return(new KeyValuePairDeserializer(mappings, resultType));
}
/// <summary>
/// Builds a deserializer.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="mappings">The mappings.</param>
/// <returns>IEnumerable<TResult>.</returns>
public IDeserializer <TResult> BuildDeserializer <TResult>(IMappingExport mappings)
{
return(new Deserializer <TResult>(Deserialize <TResult>));
}
/// <summary>
/// Builds a deserializer.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="mappings">The mappings.</param>
/// <returns>IEnumerable<TResult>.</returns>
public IDeserializer <TResult> BuildDeserializer <TResult>(IMappingExport mappings)
{
return(new KeyValuePairDeserializer <TResult>(mappings));
}
/// <summary>
/// Initializes a new instance of the <see cref="ComplexTypeDeserializer"/> class.
/// </summary>
/// <param name="mappings">The mappings.</param>
/// <param name="type">The type.</param>
/// <param name="compiledMap">The compiled mapping operations.</param>
public ComplexTypeDeserializer(IMappingExport mappings, Type type, Func<IDataReader, ColumnChecker, object> compiledMap)
{
_mappings = mappings;
_compiledMap = compiledMap;
DeserializationType = type;
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyValuePairDeserializer" /> class.
/// </summary>
/// <param name="mappings">The mappings.</param>
/// <param name="type">The type.</param>
public KeyValuePairDeserializer(IMappingExport mappings, Type type)
{
DeserializationType = type;
_props = mappings.Export();
}
/// <summary>
/// Compiles mappings.
/// </summary>
/// <returns>Func<DbDataReader, ColumnChecker, IEnumerable<System.Object>>.</returns>
public static Func <DbDataReader, ColumnChecker, object> Compile(string cacheKey, IMappingExport mapping, Type resultType)
{
//Get the properties we care about.
var mappings = mapping.Export();
var statements = new List <Expression>();
var reader = Expression.Parameter(typeof(DbDataReader), "reader");
var columnReport = Expression.Parameter(typeof(ColumnChecker), "columnReport");
var columnChecker = Expression.Variable(typeof(ColumnChecker), "columnChecker");
// columnChecker = (columnReport == null) ? new ColumnChecker() : columnReport;
statements.Add(Expression.IfThenElse(Expression.Equal(columnReport, Expression.Constant(null)),
Expression.Assign(
columnChecker, Expression.New(ColumnCheckerConstructorInfo,
Expression.Convert(Expression.Property(Expression.Convert(reader, typeof(DbDataReader)), "FieldCount"), typeof(int?)))),
Expression.Assign(columnChecker, columnReport)));
// var descriptor;
var descriptor = Expression.Variable(resultType, "descriptor");
// descriptor = new TResult();
statements.Add(Expression.Assign(
descriptor, Expression.New(resultType)));
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var pair in mappings)
{
#region locals
//These are local variables inside of a block. Similar to defining variables inside an if.
//var ex;
var ex = Expression.Variable(typeof(Exception), "ex");
//var ordinal;
var ordinal = Expression.Variable(typeof(int), "ordinal");
#endregion locals
statements.Add(
Expression.Block(new[] { /* LOCAL */ ordinal },
// ordinal = columnChecker.HasColumn(pair.Value.ActiveAlias);
Expression.Assign(ordinal,
Expression.Call(columnChecker,
typeof(ColumnChecker).GetTypeInfo().GetMethod("HasColumn",
new[] { typeof(DbDataReader), typeof(string) }),
reader,
Expression.Constant(pair.Value.ActiveAlias))),
// if(ordinal > 0 && !reader.IsDBNull(ordinal))
Expression.IfThen(
Expression.AndAlso(
Expression.IsTrue(
Expression.GreaterThanOrEqual(ordinal, Expression.Constant(0))),
Expression.IsFalse(
Expression.Call(reader, typeof(DbDataReader).GetTypeInfo().GetMethod("IsDBNull"), ordinal))),
// try
Expression.TryCatch(
Expression.Block(typeof(void),
//Assignment Expression
Expression.Invoke(
pair.Value.AssembleMappingExpression(
Expression.Property(descriptor, pair.Value.PropertyMetadata)),
reader, ordinal)),
// catch
Expression.Catch(
/* Exception being caught is assigned to ex */ ex,
Expression.Block(typeof(void),
//throw new ColumnBindingException("...", ex);
Expression.Throw(
Expression.New(ColumnBindingException.MessageAndInnerExceptionConstructorInfo,
Expression.Constant(pair.Value.PropertyMetadata.Name +
" encountered an exception on column [" +
pair.Value.ActiveAlias + "] when binding"
+ " into property " +
pair.Value.PropertyMetadata.Name +
" which is CLR type of "
+ pair.Value.PropertyMetadata.PropertyType.Name +
"."),
ex
))))))));
}
statements.Add(descriptor);
var body = Expression.Block(new[] { columnChecker, descriptor }, statements);
var lambda = Expression.Lambda <Func <DbDataReader, ColumnChecker, object> >(body, reader,
columnReport);
#if !DOTNETCORE
var type = SusanooCommander.DynamicNamespace
.DefineType(string.Format(CultureInfo.CurrentCulture, "{0}_{1}",
resultType.Name, cacheKey));
var methodBuilder = type.DefineMethod("MapResult", MethodAttributes.Public | MethodAttributes.Static);
lambda.CompileToMethod(methodBuilder);
var dynamicType = type.CreateType();
return((Func <DbDataReader, ColumnChecker, object>)Delegate
.CreateDelegate(typeof(Func <DbDataReader, ColumnChecker, object>),
dynamicType.GetMethod("MapResult", BindingFlags.Public | BindingFlags.Static)));
#else
Func <DbDataReader, ColumnChecker, object> method = lambda.Compile();
return(method);
#endif
}
/// <summary>
/// Builds a deserializer.
/// </summary>
/// <param name="resultType">Type of the result.</param>
/// <param name="mappings">The mappings.</param>
/// <returns>IEnumerable<TResult>.</returns>
public IDeserializer BuildDeserializer(Type resultType, IMappingExport mappings)
{
return(new Deserializer(resultType, Deserialize));
}
