static LambdaExpression OptionalConversion(Type type, ExcelParameterRegistration paramReg, bool treatEmptyAsMissing, bool treatNAErrorAsMissing)
{
// Decide whether to return a conversion function for this parameter
if (!paramReg.CustomAttributes.OfType <OptionalAttribute>().Any())
{
return(null);
}
var defaultAttribute = paramReg.CustomAttributes.OfType <DefaultParameterValueAttribute>().FirstOrDefault();
var defaultValue = defaultAttribute == null?TypeConversion.GetDefault(type) : defaultAttribute.Value;
// var returnType = type.GetGenericArguments()[0]; // E.g. returnType is double
// Consume the attributes
paramReg.CustomAttributes.RemoveAll(att => att is OptionalAttribute);
paramReg.CustomAttributes.RemoveAll(att => att is DefaultParameterValueAttribute);
// Here's the actual conversion function
var input = Expression.Parameter(typeof(object), "input");
return
(Expression.Lambda(
Expression.Condition(
MissingTest(input, treatEmptyAsMissing, treatNAErrorAsMissing),
Expression.Constant(defaultValue, type),
TypeConversion.GetConversion(input, type)),
input));
}
public ShimParameter(Type type, ExcelParameterRegistration reg, ParameterConversionConfiguration config)
: this(type, reg.CustomAttributes)
{
// Try to find a converter for EnumeratedType
ParameterRegistration = reg;
PreparePropertyConverters(config, reg, ParameterConversionRegistration.GetParameterConversion);
}
internal static LambdaExpression NullableConversion(
ParameterConversionConfiguration config, Type type,
ExcelParameterRegistration paramReg, bool treatEmptyAsMissing,
bool treatNAErrorAsMissing)
{
// Decide whether to return a conversion function for this parameter
if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Nullable <>))
{
return(null);
}
var innerType = type.GetGenericArguments()[0]; // E.g. innerType is Complex
LambdaExpression innerTypeConversion = ParameterConversionRegistration.GetParameterConversion(config, innerType, paramReg) ??
TypeConversion.GetConversion(typeof(object), innerType);
ParameterExpression input = innerTypeConversion.Parameters[0];
// Here's the actual conversion function
var result =
Expression.Lambda(
Expression.Condition(
// if the value is missing (or possibly empty)
MissingTest(input, treatEmptyAsMissing, treatNAErrorAsMissing),
// cast null to int?
Expression.Constant(null, type),
// else convert to int, and cast that to int?
Expression.Convert(Expression.Invoke(innerTypeConversion, input), type)),
input);
return(result);
}
// Should return null if there are no conversions to apply
internal static List<LambdaExpression> GetParameterConversions(ParameterConversionConfiguration conversionConfig, Type initialParamType, ExcelParameterRegistration paramRegistration)
{
var appliedConversions = new List<LambdaExpression>();
// paramReg might be modified internally by the conversions, but won't become a different object
var paramType = initialParamType; // Might become a different type as we convert
foreach (var paramConversion in conversionConfig.ParameterConversions)
{
var lambda = paramConversion.Convert(paramType, paramRegistration);
if (lambda == null)
continue;
// We got one to apply...
// Some sanity checks
Debug.Assert(lambda.Parameters.Count == 1);
Debug.Assert(lambda.ReturnType == paramType || lambda.ReturnType.IsEquivalentTo(paramType));
appliedConversions.Add(lambda);
// Change the Parameter Type to be whatever the conversion function takes us to
// for the next round of processing
paramType = lambda.Parameters[0].Type;
}
if (appliedConversions.Count == 0)
return null;
return appliedConversions;
}
internal static LambdaExpression NullableConversion(
ParameterConversionConfiguration config, Type type,
ExcelParameterRegistration paramReg, bool treatEmptyAsMissing,
bool treatNAErrorAsMissing)
{
// Decide whether to return a conversion function for this parameter
if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Nullable<>))
return null;
var innerType = type.GetGenericArguments()[0]; // E.g. innerType is Complex
LambdaExpression innerTypeConversion = ParameterConversionRegistration.GetParameterConversion(config, innerType, paramReg) ??
TypeConversion.GetConversion(typeof(object), innerType);
ParameterExpression input = innerTypeConversion.Parameters[0];
// Here's the actual conversion function
var result =
Expression.Lambda(
Expression.Condition(
// if the value is missing (or possibly empty)
MissingTest(input, treatEmptyAsMissing, treatNAErrorAsMissing),
// cast null to int?
Expression.Constant(null, type),
// else convert to int, and cast that to int?
Expression.Convert(Expression.Invoke(innerTypeConversion, input), type)),
input);
return result;
}
internal LambdaExpression Convert(Type paramType, ExcelParameterRegistration paramReg)
{
if (TypeFilter != null && paramType != TypeFilter)
{
return(null);
}
return(Conversion(paramType, paramReg));
}
internal static LambdaExpression NullableConversion(
IEnumerable <ParameterConversionConfiguration.ParameterConversion> parameterConversions, Type type,
ExcelParameterRegistration paramReg, bool treatEmptyAsMissing,
bool treatNAErrorAsMissing)
{
// Decide whether to return a conversion function for this parameter
if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Nullable <>))
{
return(null);
}
var innerType = type.GetGenericArguments()[0]; // E.g. innerType is Complex
// Try to find a converter for innerType in the config
ParameterConversionConfiguration.ParameterConversion innerTypeParameterConversion = null;
if (parameterConversions != null)
{
innerTypeParameterConversion =
parameterConversions.FirstOrDefault(c => c.Convert(innerType, paramReg) != null);
}
ParameterExpression input = null;
Expression innerTypeConversion = null;
// if we have a converter for innertype in the config, then use it. Otherwise try one of the conversions for the basic types
if (innerTypeParameterConversion == null)
{
input = Expression.Parameter(typeof(object), "input");
innerTypeConversion = TypeConversion.GetConversion(input, innerType);
}
else
{
var innerTypeParamConverter = innerTypeParameterConversion.Convert(innerType, paramReg);
input = Expression.Parameter(innerTypeParamConverter.Parameters[0].Type, "input");
innerTypeConversion = Expression.Invoke(innerTypeParamConverter, input);
}
// Here's the actual conversion function
var result =
Expression.Lambda(
Expression.Condition(
// if the value is missing (or possibly empty)
MissingTest(input, treatEmptyAsMissing, treatNAErrorAsMissing),
// cast null to int?
Expression.Constant(null, type),
// else convert to int, and cast that to int?
Expression.Convert(innerTypeConversion, type)),
input);
return(result);
}
static LambdaExpression EnumStringConversion(Type type, ExcelParameterRegistration paramReg)
{
// Decide whether to return a conversion function for this parameter
if (!type.IsEnum)
return null;
var input = Expression.Parameter(typeof(object), "input");
var enumTypeParam = Expression.Parameter(typeof(Type), "enumType");
Expression<Func<Type, object, object>> enumParse = (t, s) => EnumParse(t, s);
var result =
Expression.Lambda(
Expression.Convert(
Expression.Invoke(enumParse, Expression.Constant(type), input),
type),
input);
return result;
}
static LambdaExpression EnumStringConversion(Type type, ExcelParameterRegistration paramReg)
{
// Decide whether to return a conversion function for this parameter
if (!type.IsEnum)
{
return(null);
}
var input = Expression.Parameter(typeof(object), "input");
var enumTypeParam = Expression.Parameter(typeof(Type), "enumType");
Expression <Func <Type, object, object> > enumParse = (t, s) => EnumParse(t, s);
var result =
Expression.Lambda(
Expression.Convert(
Expression.Invoke(enumParse, Expression.Constant(type), input),
type),
input);
return(result);
}
// Implementations
static LambdaExpression NullableConversion(Type type, ExcelParameterRegistration paramReg, bool treatEmptyAsMissing)
{
// Decide whether to return a conversion function for this parameter
if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Nullable<>)) // E.g. type is Nullable<double>
return null;
var innerType = type.GetGenericArguments()[0]; // E.g. innerType is double
// Here's the actual conversion function
var input = Expression.Parameter(typeof(object));
var result =
Expression.Lambda(
Expression.Condition(
// if the value is missing (or possibly empty)
MissingTest(input, treatEmptyAsMissing),
// cast null to int?
Expression.Constant(null, type),
// else convert to int, and cast that to int?
Expression.Convert(TypeConversion.GetConversion(input, innerType), type)),
input);
return result;
}
static LambdaExpression OptionalConversion(Type type, ExcelParameterRegistration paramReg, bool treatEmptyAsMissing)
{
// Decide whether to return a conversion function for this parameter
if (!paramReg.CustomAttributes.OfType<OptionalAttribute>().Any())
return null;
var defaultAttribute = paramReg.CustomAttributes.OfType<DefaultParameterValueAttribute>().FirstOrDefault();
var defaultValue = defaultAttribute == null ? TypeConversion.GetDefault(type) : defaultAttribute.Value;
// var returnType = type.GetGenericArguments()[0]; // E.g. returnType is double
// Consume the attributes
paramReg.CustomAttributes.RemoveAll(att => att is OptionalAttribute);
paramReg.CustomAttributes.RemoveAll(att => att is DefaultParameterValueAttribute);
// Here's the actual conversion function
var input = Expression.Parameter(typeof(object));
return
Expression.Lambda(
Expression.Condition(
MissingTest(input, treatEmptyAsMissing),
Expression.Constant(defaultValue, type),
TypeConversion.GetConversion(input, type)),
input);
}
// Implementations
static LambdaExpression NullableConversion(Type type, ExcelParameterRegistration paramReg, bool treatEmptyAsMissing)
{
// Decide whether to return a conversion function for this parameter
if (!type.IsGenericType || type.GetGenericTypeDefinition() != typeof(Nullable <>)) // E.g. type is Nullable<double>
{
return(null);
}
var innerType = type.GetGenericArguments()[0]; // E.g. innerType is double
// Here's the actual conversion function
var input = Expression.Parameter(typeof(object));
var result =
Expression.Lambda(
Expression.Condition(
// if the value is missing (or possibly empty)
MissingTest(input, treatEmptyAsMissing),
// cast null to int?
Expression.Constant(null, type),
// else convert to int, and cast that to int?
Expression.Convert(TypeConversion.GetConversion(input, innerType), type)),
input);
return(result);
}
// Should return null if there are no conversions to apply
internal static List <LambdaExpression> GetParameterConversions(ParameterConversionConfiguration conversionConfig, Type initialParamType, ExcelParameterRegistration paramRegistration)
{
var appliedConversions = new List <LambdaExpression>();
// paramReg might be modified internally by the conversions, but won't become a different object
var paramType = initialParamType; // Might become a different type as we convert
foreach (var paramConversion in conversionConfig.ParameterConversions)
{
var lambda = paramConversion.Convert(paramType, paramRegistration);
if (lambda == null)
{
continue;
}
// We got one to apply...
// Some sanity checks
Debug.Assert(lambda.Parameters.Count == 1);
Debug.Assert(lambda.ReturnType == paramType || lambda.ReturnType.IsEquivalentTo(paramType));
appliedConversions.Add(lambda);
// Change the Parameter Type to be whatever the conversion function takes us to
// for the next round of processing
paramType = lambda.Parameters[0].Type;
}
if (appliedConversions.Count == 0)
{
return(null);
}
return(appliedConversions);
}
internal static LambdaExpression GetParameterConversion(ParameterConversionConfiguration conversionConfig,
Type initialParamType, ExcelParameterRegistration paramRegistration)
{
return(ComposeLambdas(GetParameterConversions(conversionConfig, initialParamType, paramRegistration)));
}
internal static LambdaExpression GetParameterConversion(ParameterConversionConfiguration conversionConfig,
Type initialParamType, ExcelParameterRegistration paramRegistration)
{
return ComposeLambdas(GetParameterConversions(conversionConfig, initialParamType, paramRegistration));
}
