public virtual void Post(ConversionArgs input)
{
foreach (var layer in FirstConversionLayers)
{
layer.Post(input);
}
}
private static void Callback(ConversionArgs args)
{
//TODO: thinking about correct getting values from args
var numArgs = args as NumericConversionArgs;
var number = numArgs.Number;
Console.WriteLine(number);
}
private bool TryParseDecimal(string value, out object result, ConversionArgs args)
{
var style = args.Options.DecimalNumberStyle;
var succeeded = decimal.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
public ConversionArgs Convert(ConversionArgs args)
{
var numArgs = args as NumericConversionArgs;
var number = numArgs.Number;
var sqr = number * number;
return(new NumericConversionArgs(sqr, this, args));
}
public ConversionArgs Convert(ConversionArgs args)
{
var numArgs = args as NumericConversionArgs;
var number = numArgs.Number;
var sqrt = Math.Sqrt(number);
return(new NumericConversionArgs(sqrt, this, args));
}
public virtual Task PostAsync(ConversionArgs input)
{
return(Task.Run(() =>
{
foreach (var layer in FirstConversionLayers)
{
layer.PostAsync(input);
}
}));
}
private bool TryParseDateTime(string value, out object result, ConversionArgs args)
{
if (DateTime.TryParse(value, args.Culture, args.Options.DateTimeStyle, out var parseResult))
{
result = parseResult;
return(true);
}
foreach (var pattern in args.Options.DateTimePatterns)
{
if (DateTime.TryParseExact(value, pattern, args.Culture, args.Options.DateTimeStyle, out parseResult))
{
result = parseResult;
return(true);
}
}
result = DateTime.MinValue;
return(false);
}
private bool TryParseFloat(string value, Type destinationType, out object result, ConversionArgs args)
{
var style = args.Options.FloatNumberStyle;
if (destinationType == typeof(float))
{
var succeeded = float.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
if (destinationType == typeof(double))
{
var succeeded = double.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
result = null;
return(false);
}
public override bool Post(ConversionArgs args)
{
return(_inputGateBlock.Post(args));
}
/// <inheritdoc />
protected override bool TryConvert(string value, Type destinationType, out object result, ConversionArgs args)
{
if (string.IsNullOrWhiteSpace(value))
{
result = null;
return(false);
}
if (IsInteger(destinationType))
{
return(TryParseInteger(value, destinationType, out result, args));
}
if (destinationType == typeof(decimal))
{
return(TryParseDecimal(value, out result, args));
}
if (IsFloat(destinationType))
{
return(TryParseFloat(value, destinationType, out result, args));
}
if (destinationType == typeof(DateTime))
{
return(TryParseDateTime(value, out result, args));
}
if (destinationType == typeof(Guid))
{
return(TryParseGuid(value, out result));
}
if (destinationType == typeof(byte[]) && args.Options.ByteArrayFormat != ByteArrayFormat.None)
{
try {
result = Convert.FromBase64String(value);
return(true);
} catch {
result = null;
return(false);
}
}
result = null;
return(false);
}
public NumericConversionArgs(double num, IConversion generatedBy = null, ConversionArgs generatedFrom = null) : base(generatedBy, generatedFrom)
{
Number = num;
}
public Task <ConversionArgs> ConvertAsync(ConversionArgs args)
{
return(Task.Run(() => Convert(args)));
}
/// <summary> /// Converts the given value to the given type. /// A return value indicates whether the operation succeeded. /// </summary> protected abstract bool TryConvert(TSource value, Type destinationType, out object result, ConversionArgs args);
/// <inheritdoc />
protected override bool TryConvert(float value, Type destinationType, out object result, ConversionArgs args)
{
if (destinationType == typeof(string))
{
result = value.ToString(args.Options.FloatFormat, args.Culture);
return(true);
}
if (destinationType == typeof(char))
{
try {
var i = Convert.ToInt16(value);
result = Convert.ToChar(i);
return(true);
} catch {
}
}
result = null;
return(false);
}
/// <inheritdoc />
public bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args)
{
if (value == null || destinationType == null || !(value is string s))
{
result = null;
return(false);
}
// Prefer IFormatProvider-Overload:
var methods = destinationType.GetMethods(BindingFlags.Public | BindingFlags.Static).Where(m => m.Name.Equals("TryParse", StringComparison.OrdinalIgnoreCase) && m.ReturnType == typeof(bool)).ToList();
foreach (var method in methods)
{
var parameters = method.GetParameters();
if (parameters.Length != 3)
{
continue;
}
if (parameters[0].ParameterType != typeof(string) ||
parameters[1].ParameterType != typeof(IFormatProvider) ||
!parameters[2].IsOut)
{
continue;
}
bool succeeded;
var paramValues = new object[] { s, args.Culture, null };
try {
succeeded = (bool)method.Invoke(null, paramValues);
} catch {
succeeded = false;
}
if (succeeded && paramValues[2] != null && paramValues[2].GetType() == destinationType)
{
result = paramValues[2];
return(true);
}
}
// Fallback withou IFormatProvider:
foreach (var method in methods)
{
var parameters = method.GetParameters();
if (parameters.Length != 2)
{
continue;
}
if (parameters[0].ParameterType != typeof(string) ||
!parameters[1].IsOut)
{
continue;
}
bool succeeded;
var paramValues = new object[] { s, null };
try {
succeeded = (bool)method.Invoke(null, paramValues);
} catch {
succeeded = false;
}
if (succeeded && paramValues[1] != null && paramValues[1].GetType() == destinationType)
{
result = paramValues[1];
return(true);
}
}
result = null;
return(false);
}
/// <inheritdoc />
public bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args)
{
if (args.Options.PropertyResolvingMode == PropertyResolvingMode.None || value == null)
{
result = null;
return(false);
}
//TODO zz Perfomance improvement on reflection.
var sourceType = value.GetType();
var constructor = sourceType.GetConstructors().FirstOrDefault(c => c.GetParameters().Length == 1 && c.GetParameters()[0].ParameterType == destinationType);
if (constructor == null)
{
constructor = sourceType.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, new[] { destinationType }, null);
}
if (constructor == null)
{
result = null;
return(false);
}
var parameterName = constructor.GetParameters()[0].Name;
var property = sourceType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.FirstOrDefault(p => p.Name.Equals(parameterName, StringComparison.OrdinalIgnoreCase));
if (property == null)
{
result = null;
return(false);
}
if (property.PropertyType == destinationType)
{
try {
result = property.GetValue(value);
return(true);
} catch {
result = null;
return(false);
}
}
if (args.Options.PropertyResolvingMode == PropertyResolvingMode.Strict)
{
result = null;
return(false);
}
object propertyValue;
try {
propertyValue = property.GetValue(value);
} catch {
result = null;
return(false);
}
return(args.Caller.TryConvert(propertyValue, destinationType, out result, args));
}
/// <inheritdoc />
protected override bool TryConvert(byte[] value, Type destinationType, out object result, ConversionArgs args)
{
if (destinationType == typeof(string))
{
switch (args.Options.ByteArrayFormat)
{
case ByteArrayFormat.Base64:
try {
result = Convert.ToBase64String(value, Base64FormattingOptions.None);
return(true);
} catch {
result = null;
return(false);
}
case ByteArrayFormat.Base64WithLineBreaks:
try {
result = Convert.ToBase64String(value, Base64FormattingOptions.InsertLineBreaks);
return(true);
} catch {
result = null;
return(false);
}
case ByteArrayFormat.None:
args.Break = true;
result = null;
return(false);
}
}
result = null;
return(false);
}
/// <inheritdoc /> public abstract bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args);
/// <inheritdoc />
protected override bool TryConvert(char value, Type destinationType, out object result, ConversionArgs args)
{
if (destinationType == typeof(double))
{
try {
var i = Convert.ToInt16(value);
result = Convert.ToDouble(i);
return(true);
} catch {
}
}
if (destinationType == typeof(float))
{
try {
var i = Convert.ToInt16(value);
result = Convert.ToSingle(i);
return(true);
} catch {
}
}
result = null;
return(false);
}
private bool TryParseInteger(string value, Type destinationType, out object result, ConversionArgs args)
{
var style = args.Options.IntegerNumberStyle;
if (IsHex(value))
{
style = NumberStyles.AllowHexSpecifier;
}
if (destinationType == typeof(byte))
{
var succeeded = byte.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
if (destinationType == typeof(int))
{
var succeeded = int.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
if (destinationType == typeof(long))
{
var succeeded = long.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
if (destinationType == typeof(sbyte))
{
var succeeded = sbyte.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
if (destinationType == typeof(short))
{
var succeeded = short.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
if (destinationType == typeof(uint))
{
var succeeded = uint.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
if (destinationType == typeof(ulong))
{
var succeeded = ulong.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
if (destinationType == typeof(ushort))
{
var succeeded = ushort.TryParse(value, style, args.Culture, out var parseResult);
result = parseResult;
return(succeeded);
}
result = null;
return(false);
}
/// <inheritdoc />
protected override bool TryConvert(IFormattable value, Type destinationType, out object result, ConversionArgs args)
{
if (destinationType != typeof(string))
{
result = null;
return(false);
}
try {
result = value.ToString(null, args.Culture);
return(true);
} catch {
}
result = null;
return(false);
}
public abstract bool Post(ConversionArgs args);
/// <inheritdoc />
public override bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args)
{
if (!(value is TSource sourceValue))
{
result = null;
return(false);
}
return(TryConvert(sourceValue, destinationType, out result, args));
}
public override Task <bool> PostAsync(ConversionArgs args)
{
return(_inputGateBlock.SendAsync(args));
}
/// <inheritdoc />
public override bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args)
{
if (IsEnum(destinationType))
{
try {
result = Enum.ToObject(destinationType, value);
return(true);
} catch {
}
}
result = null;
return(false);
}
/// <inheritdoc />
public override bool TryConvert(object value, Type destinationType, out object result, ConversionArgs args)
{
if (TryConvertXPlicit(value, destinationType, ExplicitOperatorMethodName, out result))
{
return(true);
}
if (TryConvertXPlicit(value, destinationType, ImplicitOperatorMethodName, out result))
{
return(true);
}
result = null;
return(false);
}
public abstract Task <bool> PostAsync(ConversionArgs args);
/// <inheritdoc />
protected override bool TryConvert(IConvertible value, Type destinationType, out object result, ConversionArgs args)
{
try {
if (destinationType == typeof(string))
{
result = value.ToString(args.Culture);
return(true);
}
if (destinationType == typeof(int))
{
result = value.ToInt32(args.Culture);
return(true);
}
if (destinationType == typeof(bool))
{
result = value.ToBoolean(args.Culture);
return(true);
}
if (destinationType == typeof(decimal))
{
result = value.ToDecimal(args.Culture);
return(true);
}
if (destinationType == typeof(DateTime))
{
result = value.ToDateTime(args.Culture);
return(true);
}
if (destinationType == typeof(byte))
{
result = value.ToByte(args.Culture);
return(true);
}
if (destinationType == typeof(char))
{
result = value.ToChar(args.Culture);
return(true);
}
if (destinationType == typeof(double))
{
result = value.ToDouble(args.Culture);
return(true);
}
if (destinationType == typeof(short))
{
result = value.ToInt16(args.Culture);
return(true);
}
if (destinationType == typeof(long))
{
result = value.ToInt64(args.Culture);
return(true);
}
if (destinationType == typeof(sbyte))
{
result = value.ToSByte(args.Culture);
return(true);
}
if (destinationType == typeof(float))
{
result = value.ToSingle(args.Culture);
return(true);
}
if (destinationType == typeof(ushort))
{
result = value.ToUInt16(args.Culture);
return(true);
}
if (destinationType == typeof(uint))
{
result = value.ToUInt32(args.Culture);
return(true);
}
if (destinationType == typeof(ulong))
{
result = value.ToUInt64(args.Culture);
return(true);
}
} catch {
}
try {
result = value.ToType(destinationType, args.Culture);
return(true);
} catch {
}
result = null;
return(false);
}
/// <inheritdoc />
protected override bool TryConvert(IDataRecord record, Type destinationType, out object result, ConversionArgs args)
{
if (record == null)
{
result = null;
return(false);
}
var properties = record.ToDictionary();
return(mConverter.TryCreate(destinationType, properties, out result, args.Culture));
}
/// <inheritdoc />
protected override bool TryConvert(ulong value, Type destinationType, out object result, ConversionArgs args)
{
if (destinationType == typeof(string))
{
result = value.ToString(args.Options.IntegerFormat, args.Culture);
return(true);
}
result = null;
return(false);
}
