/// <summary> /// Converts a text into the given type. If the type is a boolean, then the conversions in /// <see cref="BooleanUtilities"/> will be used. /// </summary> /// <typeparam name="T">The type to which the string is converted.</typeparam> /// <param name="s">The string, which is converted into the specified type.</param> /// <returns>A values representing the interpretation of the provided string.</returns> public static T ConvertString <T>(string s) { var tType = typeof(T); if (tType == typeof(bool)) { object b = BooleanUtilities.ToBool(s); return((T)b); } return((T)Convert.ChangeType(s, tType)); }
/// <summary> /// <para>Parses the provided string into the specified type. This is done in the following way:</para> /// <para>1. If the provided value is null, then an <see cref="NullParameterException"/> is thrown.</para> /// <para>2. If the specified type is an enum type, then the provided value is parsed into that enum value and returned.</para> /// <para>3. If the specified type is not contained in <see cref="TypeNames"/> then an <see cref="UnsupportedTypeException"/> is thrown.</para> /// <para>4. If the specified type is a string, then the provided string value is returned.</para> /// <para>5. If the specified type is a boolean, then the provided string value is converted to the boolean value.</para> /// <para>6. If the specified type can be mapped to an entry in <see cref="NumericParsers"/>, then that parser is used to parse the provided string</para> /// <para>value into a numeric value and the numeric value is returned.</para> /// <para>Otherwise an <see cref="UnsupportedTypeException"/> is thrown.</para> /// </summary> /// <param name="value">The value, which will be parsed.</param> /// <param name="typeName">The name of the type, which is used to determine how the parsing is performed.</param> /// <returns>The result of the parsing.</returns> public static object ParseToType(string value, string typeName) { if (value == null) { throw new NullParameterException("value"); } if (!TypeNames.ContainsKey(typeName)) { var type = GetType(typeName); if (type == null) { throw new UnsupportedTypeException(value, typeName); } if (type.IsEnum) { return(Enum.Parse(type, value)); } throw new UnsupportedTypeException(value, typeName); } { var type = TypeNames[typeName]; if (type == typeof(string)) { return(value); } if (type == typeof(bool)) { return(BooleanUtilities.ToBool(value)); } if (NumericParsers.ContainsKey(type)) { return(NumericParsers[type](value)); } } throw new UnsupportedTypeException(value, typeName); }