コード例 #1
0
        /// <summary>
        ///     Infer from the input string what type it is, and return the field as that type
        ///     (int, long, decimal, double, bool or string)
        /// </summary>
        /// <param name="input">the input sting</param>
        /// <returns>the value cast to the type it could be parsed into</returns>
        public static object CastToInferredType(this string input)
        {
            var target = input;

            // we infer hex numbers to be signed; size in bytes determines which return value to be used
            // (byte, short, int, long)
            if (NumericFunctions.TryParseHex(input, true, out var hexValue))
            {
                target = hexValue.ToString();
            }
            if (int.TryParse(target, out var intValue))
            {
                return(intValue);
            }
            if (long.TryParse(target, out var longValue))
            {
                return(longValue);
            }
            if (decimal.TryParse(target, out var decimalValue))
            {
                return(decimalValue);
            }
            if (double.TryParse(target, out var doubleValue))
            {
                return(doubleValue);
            }
            if (bool.TryParse(target, out var boolValue))
            {
                return(boolValue);
            }
            return(input);
        }
コード例 #2
0
        private static object ChangeType(object value, Type targetType)
        {
            var source = value;

            // if we want a numeric result and we have a hex value, convert the hex to long first.
            if (targetType.IsNumeric() &&
                NumericFunctions.TryParseHex(value?.ToString(), targetType.IsSigned(), out var hexValue))
            {
                source = hexValue;
            }
            try
            {
                return(Convert.ChangeType(source, targetType, InvariantCulture));
            }
            catch (Exception e) when(e is FormatException || e is InvalidCastException)
            {
                try
                {
                    return(Convert.ChangeType(source, targetType, CurrentUICulture));
                }
                catch (Exception fe) when(fe is FormatException || fe is InvalidCastException)
                {
                    throw new FormatException(Invariant($"Could not convert '{value}' to {targetType.Name}"), fe);
                }
            }
        }
コード例 #3
0
        /// <summary>
        ///     Get the type that the input value can be parsed into (int, long, double, bool, string)
        /// </summary>
        /// <param name="value">the value to be examined</param>
        /// <returns>The type it was successfully parsed into</returns>
        public static Type InferType(this object value)
        {
            var stringValue = value?.ToString();

            // we infer hex numbers to be signed, see CastToInferredType
            if (NumericFunctions.TryParseHex(stringValue, true, out var hexValue))
            {
                stringValue = hexValue.ToString();
            }
            if (int.TryParse(stringValue, NumberStyles.Integer, InvariantCulture, out _))
            {
                return(typeof(int));
            }
            if (long.TryParse(stringValue, NumberStyles.Integer, InvariantCulture, out _))
            {
                return(typeof(long));
            }
            if (double.TryParse(stringValue, NumberStyles.Any, InvariantCulture, out _))
            {
                return(typeof(double));
            }
            if (double.TryParse(stringValue, NumberStyles.Any, CurrentUICulture, out _))
            {
                return(typeof(double));
            }
            return(bool.TryParse(stringValue, out _) ? typeof(bool) : typeof(string));
        }