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