private static Expression GetStringValueConversion(
Expression sourceValue,
Expression fallbackValue,
Type nonNullableTargetEnumType)
{
if (sourceValue.Type != typeof(string))
{
sourceValue = ToStringConverter.GetConversion(sourceValue);
}
var underlyingEnumType = Enum.GetUnderlyingType(nonNullableTargetEnumType);
var isNumericTest = GetIsNumericTest(sourceValue);
var numericConversion = GetNumericStringToEnumConversion(
sourceValue,
fallbackValue,
nonNullableTargetEnumType,
underlyingEnumType);
var nameMatchingConversion = GetStringToEnumConversion(
sourceValue,
fallbackValue,
nonNullableTargetEnumType);
var numericOrNameConversion = Expression.Condition(
isNumericTest,
numericConversion,
nameMatchingConversion);
var valueIsNullOrEmpty = Expression.Call(
#if NET35
typeof(StringExtensions)
#else
typeof(string)
#endif
.GetPublicStaticMethod("IsNullOrWhiteSpace"),
sourceValue);
var convertedValueOrDefault = Expression.Condition(
valueIsNullOrEmpty,
fallbackValue,
numericOrNameConversion);
return(convertedValueOrDefault);
}
private static Expression GetFromNumericConversion(Expression sourceValue, Type targetType)
{
var isWholeNumberNumeric = sourceValue.Type.GetNonNullableType().IsWholeNumberNumeric();
var sourceValueIsValid = GetIsValidNumericValueCheck(sourceValue, isWholeNumberNumeric);
var fallbackValue = targetType.ToDefaultExpression();
var stringValue = ToStringConverter.GetConversion(sourceValue);
if (!isWholeNumberNumeric)
{
stringValue = stringValue.GetFirstOrDefaultCall();
}
var convertedStringValue = GetFromStringConversion(stringValue, targetType);
return(Expression.Condition(sourceValueIsValid, fallbackValue, convertedStringValue));
}
protected static Expression GetConversion(
Expression sourceValue,
Type targetType,
MethodInfo tryParseMethod,
ParameterExpression valueVariable)
{
if (sourceValue.Type != typeof(string))
{
sourceValue = ToStringConverter.GetConversion(sourceValue);
}
var tryParseCall = Expression.Call(tryParseMethod, sourceValue, valueVariable);
var successfulParseReturnValue = valueVariable.GetConversionTo(targetType);
var defaultValue = targetType.ToDefaultExpression();
var parsedValueOrDefault = Expression.Condition(tryParseCall, successfulParseReturnValue, defaultValue);
var tryParseBlock = Expression.Block(new[] { valueVariable }, parsedValueOrDefault);
return(tryParseBlock);
}
public Expression GetConversion(Expression sourceValue, Type targetType)
{
if (sourceValue.Type == typeof(Guid?))
{
return(sourceValue.GetValueOrDefaultCall());
}
if (sourceValue.Type != typeof(string))
{
sourceValue = ToStringConverter.GetConversion(sourceValue);
}
var parseMethod = targetType == typeof(Guid)
? _parseGuidMethod
: _parseGuidNullableMethod;
var parseCall = Expression.Call(parseMethod, sourceValue);
return(parseCall);
}
public ConverterSet()
{
var toStringConverter = new ToStringConverter();
_converters = new List <IValueConverter>
{
toStringConverter,
new ToNumericConverter <int>(toStringConverter),
new ToBoolConverter(),
new ToEnumConverter(toStringConverter),
new DefaultTryParseConverter <DateTime>(toStringConverter),
new DefaultTryParseConverter <Guid>(toStringConverter),
new ToNumericConverter <decimal>(toStringConverter),
new ToNumericConverter <double>(toStringConverter),
new ToNumericConverter <long>(toStringConverter),
new ToNumericConverter <short>(toStringConverter),
new ToNumericConverter <byte>(toStringConverter),
new FallbackNonSimpleTypeValueConverter()
};
}
private static Expression GetStringValueConversion(
Expression sourceValue,
Expression fallbackValue,
Type nonNullableTargetEnumType)
{
if (sourceValue.Type != typeof(string))
{
sourceValue = ToStringConverter.GetConversion(sourceValue);
}
var underlyingEnumType = Enum.GetUnderlyingType(nonNullableTargetEnumType);
var isNumericTest = GetIsNumericTest(sourceValue);
var numericConversion = GetNumericStringToEnumConversion(
sourceValue,
fallbackValue,
nonNullableTargetEnumType,
underlyingEnumType);
var nameMatchingConversion = GetStringToEnumConversion(
sourceValue,
fallbackValue,
nonNullableTargetEnumType);
var numericOrNameConversion = Expression.Condition(
isNumericTest,
numericConversion,
nameMatchingConversion);
var convertedValueOrDefault = Expression.Condition(
StringExpressionExtensions.GetIsNullOrWhiteSpaceCall(sourceValue),
fallbackValue,
numericOrNameConversion);
return(convertedValueOrDefault);
}
public Expression GetConversion(Expression sourceValue, Type targetType)
{
if (sourceValue.Type == typeof(char?))
{
return(sourceValue.GetValueOrDefaultCall());
}
if (sourceValue.Type == typeof(object))
{
sourceValue = ToStringConverter.GetConversion(sourceValue);
}
if (sourceValue.Type == typeof(string))
{
return(GetFromStringConversion(sourceValue, targetType));
}
if (sourceValue.Type.GetNonNullableType().IsEnum())
{
sourceValue = sourceValue.GetConversionTo <int>();
}
return(GetFromNumericConversion(sourceValue, targetType));
}
public ToEnumConverter(ToStringConverter toStringConverter)
{
_toStringConverter = toStringConverter;
}
public DefaultTryParseConverter(ToStringConverter toStringConverter)
: base(toStringConverter, typeof(T))
{
}
private static Expression GetFlagsEnumConversion(
Expression sourceValue,
Expression fallbackValue,
Type nonNullableSourceType,
Type nonNullableTargetEnumType)
{
var enumTypeName = GetVariableNameFor(nonNullableTargetEnumType);
var underlyingEnumType = Enum.GetUnderlyingType(nonNullableTargetEnumType);
var enumValueVariable = Expression.Variable(underlyingEnumType, enumTypeName + "Value");
var underlyingTypeDefault = underlyingEnumType.ToDefaultExpression();
var assignEnumValue = enumValueVariable.AssignTo(underlyingTypeDefault);
if (nonNullableSourceType.IsNumeric())
{
return(GetNumericToFlagsEnumConversion(
sourceValue,
fallbackValue,
nonNullableTargetEnumType,
enumTypeName,
enumValueVariable,
assignEnumValue));
}
if (sourceValue.Type != typeof(string))
{
sourceValue = ToStringConverter.GetConversion(sourceValue);
}
var sourceValuesVariable = GetEnumValuesVariable(enumTypeName, typeof(string));
var splitSourceValueCall = Expression.Call(
sourceValue,
typeof(string).GetPublicInstanceMethod("Split", typeof(char[])),
Expression.NewArrayInit(typeof(char), ','.ToConstantExpression()));
var assignSourceValues = GetValuesEnumeratorAssignment(sourceValuesVariable, splitSourceValueCall);
var ifNotMoveNextBreak = GetLoopExitCheck(sourceValuesVariable, out var loopBreakTarget);
var localSourceValueVariable = Expression.Variable(typeof(string), enumTypeName);
var enumeratorCurrent = Expression.Property(sourceValuesVariable, "Current");
var stringTrimMethod = typeof(string).GetPublicInstanceMethod("Trim", parameterCount: 0);
var currentTrimmed = Expression.Call(enumeratorCurrent, stringTrimMethod);
var assignLocalVariable = localSourceValueVariable.AssignTo(currentTrimmed);
var isNumericTest = GetIsNumericTest(localSourceValueVariable);
var sourceNumericValueVariableName = enumTypeName + underlyingEnumType.Name + "Value";
var sourceNumericValueVariable = Expression.Variable(underlyingEnumType, sourceNumericValueVariableName);
var parsedString = GetStringParseCall(localSourceValueVariable, underlyingEnumType);
var assignNumericVariable = sourceNumericValueVariable.AssignTo(parsedString);
var numericValuePopulationLoop = GetNumericToFlagsEnumPopulationLoop(
nonNullableTargetEnumType,
enumTypeName,
enumValueVariable,
sourceNumericValueVariable,
out var enumValuesVariable,
out var assignEnumValues);
var numericValuePopulationBlock = Expression.Block(
new[] { enumValuesVariable },
assignNumericVariable,
assignEnumValues,
numericValuePopulationLoop);
var stringValueConversion = GetStringToEnumConversion(
localSourceValueVariable,
underlyingTypeDefault,
nonNullableTargetEnumType);
var assignParsedEnumValue = Expression.OrAssign(enumValueVariable, stringValueConversion);
var assignValidValuesIfPossible = Expression.IfThenElse(
isNumericTest,
numericValuePopulationBlock,
assignParsedEnumValue);
var loopBody = Expression.Block(
new[] { localSourceValueVariable, sourceNumericValueVariable },
ifNotMoveNextBreak,
assignLocalVariable,
assignValidValuesIfPossible);
var populationBlock = Expression.Block(
new[] { sourceValuesVariable, enumValueVariable },
assignEnumValue,
assignSourceValues,
Expression.Loop(loopBody, loopBreakTarget),
enumValueVariable.GetConversionTo(fallbackValue.Type));
return(populationBlock);
}
protected ToNumericConverterBase(ToStringConverter toStringConverter, Type numericType)
: base(toStringConverter, numericType)
{
}
public virtual bool CanConvert(Type nonNullableSourceType, Type nonNullableTargetType)
{
return((GetTryParseMethod(nonNullableTargetType) != null) &&
ToStringConverter.HasNativeStringRepresentation(nonNullableSourceType));
}
public ToNumericConverter(ToStringConverter toStringConverter)
: base(toStringConverter, typeof(TNumeric))
{
}
