private ScriptUserdataField GetField(string strName) { if (m_FieldInfos.ContainsKey(strName)) { return(m_FieldInfos[strName]); } ScriptUserdataField field = new ScriptUserdataField(); field.name = strName; FieldInfo info = ValueType.GetField(strName); if (info != null) { field.field = info; field.fieldType = info.FieldType; m_FieldInfos.Add(strName, field); return(field); } MethodInfo method = ValueType.GetMethod("get_" + strName); if (method != null) { field.getMethod = method; field.fieldType = method.ReturnType; field.setMethod = ValueType.GetMethod("set_" + strName); m_FieldInfos.Add(strName, field); return(field); } method = ValueType.GetMethod("set_" + strName); if (method != null) { field.setMethod = method; field.fieldType = method.GetParameters()[0].ParameterType; field.getMethod = ValueType.GetMethod("get_" + strName); m_FieldInfos.Add(strName, field); return(field); } return(null); }
public void SetValue() { if (DbParameter == null) { return; } if (IsNull) { DbParameter.Value = DBNull.Value; } if (ValueType == typeof(string) || ValueType.IsSubclassOf(typeof(string))) { DbParameter.Value = string.IsNullOrEmpty(Value) ? (object)DBNull.Value : Value; return; } if (string.IsNullOrEmpty(Value)) { DbParameter.Value = DBNull.Value; return; } MethodInfo mi = null; if (!string.IsNullOrEmpty(StringFormat)) { mi = ValueType.GetMethod("ParseExact", new Type[] { typeof(string), typeof(string) }); if (mi != null) { DbParameter.Value = mi.Invoke(null, new object[] { Value, StringFormat }); return; } } mi = ValueType.GetMethod("Parse", new Type[] { typeof(string) }); if (mi == null) { throw new NotSupportedException(); } DbParameter.Value = mi.Invoke(null, new object[] { Value }); }
public override void Initialize(ParserInitializeArgs args) { base.Initialize(args); if (args.Push(this)) { if (ValueType != null) { var style = NumberStyles.None; if (AllowSign) { style |= NumberStyles.AllowLeadingSign; } if (AllowDecimal) { style |= NumberStyles.AllowDecimalPoint; } if (AllowExponent) { style |= NumberStyles.AllowExponent; } var numberFormat = Culture.NumberFormat; if (typeof(decimal) == ValueType) { getValue = text => decimal.Parse(text, style, numberFormat); } else if (typeof(Int16) == ValueType) { getValue = text => Int16.Parse(text, style, numberFormat); } else if (typeof(Int32) == ValueType) { getValue = text => Int32.Parse(text, style, numberFormat); } else if (typeof(Int64) == ValueType) { getValue = text => Int64.Parse(text, style, numberFormat); } else if (typeof(UInt16) == ValueType) { getValue = text => UInt16.Parse(text, style, numberFormat); } else if (typeof(UInt32) == ValueType) { getValue = text => UInt32.Parse(text, style, numberFormat); } else if (typeof(UInt64) == ValueType) { getValue = text => UInt64.Parse(text, style, numberFormat); } else if (typeof(double) == ValueType) { getValue = text => double.Parse(text, style, numberFormat); } else if (typeof(float) == ValueType) { getValue = text => float.Parse(text, style, numberFormat); } else { #if PCL var parameters = new [] { typeof(string), typeof(NumberStyles) }; var parseMethod = ValueType.GetTypeInfo().DeclaredMethods.FirstOrDefault(r => r.Name == "Parse" && r.GetParameters().Select(p => p.ParameterType).SequenceEqual(parameters)); #else var parseMethod = ValueType.GetMethod("Parse", BindingFlags.Static | BindingFlags.Public, null, new Type[] { typeof(string), typeof(NumberStyles) }, null); #endif getValue = text => parseMethod.Invoke(null, new object[] { text, style }); } } args.Pop(); } }
/// <inheritdoc /> public object ParseValue(string text, string stringMarker = null, IFormatProvider provider = null) { if (provider == null) { provider = CultureInfo.InvariantCulture; } if (ValueType == null) { throw new InvalidOperationException("This function requires a valid ValueType!"); } if (text == null) { return(null); } if (stringMarker != null) { if (text == "null") { return(null); } } switch (DataType) { case DataType.TimeSpan: { if (string.IsNullOrEmpty(text) || (text == "null")) { return(IsNullable ? null : (object)default(TimeSpan)); } switch (DateTimeType) { default: throw new NotSupportedException($"DateTimeType {DateTimeType} is not supported."); case DateTimeType.BigIntHumanReadable: return(new TimeSpan(DateTime.ParseExact(text, Storage.BigIntDateTimeFormat, provider).Ticks)); case DateTimeType.Undefined: case DateTimeType.Native: if (stringMarker != null) { text = text.Unbox(stringMarker, false); } #if NET20 || NET35 return(TimeSpan.Parse(text)); #else return(TimeSpan.Parse(text, provider)); #endif case DateTimeType.BigIntTicks: return(new TimeSpan(long.Parse(text, provider))); case DateTimeType.DecimalSeconds: return(new TimeSpan((long)decimal.Round(decimal.Parse(text, provider) * TimeSpan.TicksPerSecond))); case DateTimeType.DoubleSeconds: { var value = double.Parse(text, provider) * TimeSpan.TicksPerSecond; var longValue = (long)value; if ((value > 0) && (longValue < 0)) { Trace.WriteLine("DoubleSeconds exceeded (long) range. Overflow detected!"); longValue = long.MaxValue; } else if ((value < 0) && (longValue > 0)) { Trace.WriteLine("DoubleSeconds exceeded (long) range. Overflow detected!"); longValue = long.MinValue; } return(new TimeSpan(longValue)); } } } case DataType.DateTime: { if (string.IsNullOrEmpty(text) || (text == "null")) { return(IsNullable ? null : (object)default(DateTime)); } switch (DateTimeType) { default: throw new NotSupportedException($"DateTimeType {DateTimeType} is not supported."); case DateTimeType.BigIntHumanReadable: return(DateTime.ParseExact(text, Storage.BigIntDateTimeFormat, provider)); case DateTimeType.Undefined: case DateTimeType.Native: if (stringMarker != null) { text = text.Unbox(stringMarker, false); } return(DateTime.ParseExact(text, StringExtensions.InterOpDateTimeFormat, provider)); case DateTimeType.BigIntTicks: return(new DateTime(long.Parse(text, provider), DateTimeKind)); case DateTimeType.DecimalSeconds: return(new DateTime((long)decimal.Round(decimal.Parse(text, provider) * TimeSpan.TicksPerSecond), DateTimeKind)); case DateTimeType.DoubleSeconds: return(new DateTime((long)Math.Round(double.Parse(text, provider) * TimeSpan.TicksPerSecond), DateTimeKind)); case DateTimeType.DoubleEpoch: return(new DateTime((long)Math.Round(double.Parse(text, provider) * TimeSpan.TicksPerSecond) + Storage.EpochTicks, DateTimeKind)); } } case DataType.Binary: { if (string.IsNullOrEmpty(text) || (text == "null")) { return(null); } if (stringMarker != null) { text = text.Unbox(stringMarker, false); } return(Base64.NoPadding.Decode(text)); } case DataType.Bool: if (text.Length == 0) { return(IsNullable ? null : (object)false); } return((text.ToUpperInvariant() == "TRUE") || (text.ToUpperInvariant() == "YES") || (text == "1")); case DataType.Single: if (text.Length == 0) { return(IsNullable ? null : (object)0f); } return(float.Parse(text, provider)); case DataType.Double: if (text.Length == 0) { return(IsNullable ? null : (object)0d); } return(double.Parse(text, provider)); case DataType.Decimal: if (text.Length == 0) { return(IsNullable ? null : (object)0m); } return(decimal.Parse(text, provider)); case DataType.Int8: if (text.Length == 0) { return(IsNullable ? null : (object)(sbyte)0); } return(sbyte.Parse(text, provider)); case DataType.Int16: if (text.Length == 0) { return(IsNullable ? null : (object)(short)0); } return(short.Parse(text, provider)); case DataType.Int32: if (text.Length == 0) { return(IsNullable ? null : (object)0); } return(int.Parse(text, provider)); case DataType.Int64: if (text.Length == 0) { return(IsNullable ? null : (object)0L); } return(long.Parse(text, provider)); case DataType.UInt8: if (text.Length == 0) { return(IsNullable ? null : (object)(byte)0); } return(byte.Parse(text, provider)); case DataType.UInt16: if (text.Length == 0) { return(IsNullable ? null : (object)(ushort)0); } return(ushort.Parse(text, provider)); case DataType.UInt32: if (text.Length == 0) { return(IsNullable ? null : (object)0U); } return(uint.Parse(text, provider)); case DataType.UInt64: if (text.Length == 0) { return(IsNullable ? null : (object)0UL); } return(ulong.Parse(text, provider)); case DataType.Enum: if (stringMarker != null) { text = text.Unbox(stringMarker, false); } if (text.Length == 0) { text = "0"; } return(Enum.Parse(ValueType, text, true)); case DataType.Char: if (stringMarker != null) { text = text.Unbox(stringMarker, false).Unescape(); } if (text.Length != 1) { throw new InvalidDataException(); } return(text[0]); case DataType.String: if (stringMarker != null) { text = text.Unbox(stringMarker, false).Unescape(); } return(text); case DataType.User: break; default: throw new NotImplementedException(); } if (stringMarker != null) { text = text.Unbox(stringMarker, false).Unescape(); } if (!parserInitialized) { // lookup static Parse(string) method first staticParse = ValueType.GetMethod("Parse", BindingFlags.Public | BindingFlags.Static, null, new[] { typeof(string) }, null); // if there is none, search constructor(string) if (staticParse == null) { constructor = ValueType.GetConstructor(new[] { typeof(string) }); } parserInitialized = true; } // has static Parse(string) ? if (staticParse != null) { // use method to parse value return(staticParse.Invoke(null, new object[] { text })); } // has constructor(string) ? if (constructor != null) { return(constructor.Invoke(new object[] { text })); } throw new MissingMethodException($"Could not find a way to parse or create {ValueType} from string!"); }