/// <summary> /// Converts the given value object to the specified type, using the arguments. /// </summary> /// <param name="source">the object to convert.</param> /// <param name="targetType">The Type to convert the value parameter to.</param> /// <returns>the converted object.</returns> /// <remarks> /// <para> /// Uses the <see cref="M:PatternString.Format()"/> method to convert the /// <see cref="PatternString"/> argument to a <see cref="string"/>. /// </para> /// </remarks> /// <exception cref="ConversionNotSupportedException"> /// The <paramref name="source"/> object cannot be converted to the /// <paramref name="targetType"/>. To check for this condition use the /// <see cref="CanConvertTo"/> method. /// </exception> public object ConvertTo(object source, Type targetType) { PatternString patternString = source as PatternString; if (patternString != null && this.CanConvertTo(targetType)) { return(patternString.Format()); } throw ConversionNotSupportedException.Create(targetType, source); }
/// <summary> /// Overrides the ConvertFrom method of IConvertFrom. /// </summary> /// <param name="source">the object to convert to a PatternString.</param> /// <returns>the PatternString.</returns> /// <remarks> /// <para> /// Creates and returns a new <see cref="PatternString"/> using /// the <paramref name="source"/> <see cref="string"/> as the /// <see cref="PatternString.ConversionPattern"/>. /// </para> /// </remarks> /// <exception cref="ConversionNotSupportedException"> /// The <paramref name="source"/> object cannot be converted to the /// target type. To check for this condition use the <see cref="CanConvertFrom"/> /// method. /// </exception> public object ConvertFrom(object source) { string str = source as string; if (str != null) { return(new PatternString(str)); } throw ConversionNotSupportedException.Create(typeof(PatternString), source); }
/// <summary> /// Overrides the ConvertFrom method of IConvertFrom. /// </summary> /// <param name="source">the object to convert to an IPAddress</param> /// <returns>the IPAddress</returns> /// <remarks> /// <para> /// Uses the <see cref="IPAddress.Parse"/> method to convert the /// <see cref="String"/> argument to an <see cref="IPAddress"/>. /// If that fails then the string is resolved as a DNS hostname. /// </para> /// </remarks> /// <exception cref="ConversionNotSupportedException"> /// The <paramref name="source"/> object cannot be converted to the /// target type. To check for this condition use the <see cref="CanConvertFrom"/> /// method. /// </exception> public object ConvertFrom(object source) { string str = source as string; if (str != null && str.Length > 0) { try { #if NET_2_0 // Try to resolve via DNS. This is a blocking call. // GetHostEntry works with either an IPAddress string or a host name IPHostEntry host = Dns.GetHostEntry(str); if (host != null && host.AddressList != null && host.AddressList.Length > 0 && host.AddressList[0] != null) { return(host.AddressList[0]); } #else // Before .NET 2 we need to try to parse the IPAddress from the string first // Check if the string only contains IP address valid chars if (str.Trim(validIpAddressChars).Length == 0) { try { // try to parse the string as an IP address return(IPAddress.Parse(str)); } catch (FormatException) { // Ignore a FormatException, try to resolve via DNS } } // Try to resolve via DNS. This is a blocking call. IPHostEntry host = Dns.GetHostEntry(str); if (host != null && host.AddressList != null && host.AddressList.Length > 0 && host.AddressList[0] != null) { return(host.AddressList[0]); } #endif } catch (Exception ex) { throw ConversionNotSupportedException.Create(typeof(IPAddress), source, ex); } } throw ConversionNotSupportedException.Create(typeof(IPAddress), source); }
/// <summary> /// Convert the source object to the type supported by this object. /// </summary> /// <param name="source">the object to convert.</param> /// <returns>the converted object.</returns> /// <remarks> /// <para> /// Uses the <see cref="bool.Parse"/> method to convert the /// <see cref="string"/> argument to a <see cref="bool"/>. /// </para> /// </remarks> /// <exception cref="ConversionNotSupportedException"> /// The <paramref name="source"/> object cannot be converted to the /// target type. To check for this condition use the <see cref="CanConvertFrom"/> /// method. /// </exception> public object ConvertFrom(object source) { string str = source as string; if (str != null) { return(bool.Parse(str)); } throw ConversionNotSupportedException.Create(typeof(bool), source); }
/// <summary> /// Overrides the ConvertFrom method of IConvertFrom. /// </summary> /// <param name="source">the object to convert to a Type</param> /// <returns>the Type</returns> /// <remarks> /// <para> /// Uses the <see cref="M:Type.GetType(string,bool)"/> method to convert the /// <see cref="String"/> argument to a <see cref="Type"/>. /// Additional effort is made to locate partially specified types /// by searching the loaded assemblies. /// </para> /// </remarks> /// <exception cref="ConversionNotSupportedException"> /// The <paramref name="source"/> object cannot be converted to the /// target type. To check for this condition use the <see cref="CanConvertFrom"/> /// method. /// </exception> public object ConvertFrom(object source) { string str = source as string; if (str != null) { #if NETSTANDARD1_3 // TODO can we use ComponentModel here? return(SystemInfo.GetTypeFromString(GetType().GetTypeInfo().Assembly, str, true, true)); #else return(SystemInfo.GetTypeFromString(str, true, true)); #endif } throw ConversionNotSupportedException.Create(typeof(Type), source); }
/// <summary> /// Overrides the ConvertFrom method of IConvertFrom. /// </summary> /// <param name="source">the object to convert to an IPAddress</param> /// <returns>the IPAddress</returns> /// <remarks> /// <para> /// Uses the <see cref="IPAddress.Parse"/> method to convert the /// <see cref="String"/> argument to an <see cref="IPAddress"/>. /// If that fails then the string is resolved as a DNS hostname. /// </para> /// </remarks> /// <exception cref="ConversionNotSupportedException"> /// The <paramref name="source"/> object cannot be converted to the /// target type. To check for this condition use the <see cref="CanConvertFrom"/> /// method. /// </exception> public object ConvertFrom(object source) { var str = source as string; if (str != null && str.Length > 0) { try { // Try to resolve via DNS. This is a blocking call. // GetHostEntry works with either an IPAddress string or a host name var host = Dns.GetHostEntry(str); if (host != null && host.AddressList != null && host.AddressList.Length > 0 && host.AddressList[0] != null) { return(host.AddressList[0]); } } catch (Exception ex) { throw ConversionNotSupportedException.Create(typeof(IPAddress), source, ex); } } throw ConversionNotSupportedException.Create(typeof(IPAddress), source); }
/// <summary> /// Overrides the ConvertFrom method of IConvertFrom. /// </summary> /// <param name="source">the object to convert to an IPAddress</param> /// <returns>the IPAddress</returns> /// <remarks> /// <para> /// Uses the <see cref="IPAddress.Parse"/> method to convert the /// <see cref="String"/> argument to an <see cref="IPAddress"/>. /// If that fails then the string is resolved as a DNS hostname. /// </para> /// </remarks> /// <exception cref="ConversionNotSupportedException"> /// The <paramref name="source"/> object cannot be converted to the /// target type. To check for this condition use the <see cref="CanConvertFrom"/> /// method. /// </exception> public object ConvertFrom(object source) { string str = source as string; if (str != null && str.Length > 0) { try { #if NET_2_0 || NETCF_2_0 #if !NETCF_2_0 // Try an explicit parse of string representation of an IPAddress (v4 or v6) IPAddress result; if (IPAddress.TryParse(str, out result)) { return(result); } #endif // Try to resolve via DNS. This is a blocking call. // GetHostEntry works with either an IPAddress string or a host name IPHostEntry host = Dns.GetHostEntry(str); if (host != null && host.AddressList != null && host.AddressList.Length > 0 && host.AddressList[0] != null) { return(host.AddressList[0]); } #else // Before .NET 2 we need to try to parse the IPAddress from the string first // Check if the string only contains IP address valid chars if (str.Trim(validIpAddressChars).Length == 0) { try { // try to parse the string as an IP address return(IPAddress.Parse(str)); } catch (FormatException) { // Ignore a FormatException, try to resolve via DNS } } // Try to resolve via DNS. This is a blocking call. #if NETSTANDARD1_3 || NETSTANDARD2_0 IPHostEntry host = Dns.GetHostEntryAsync(str).GetAwaiter().GetResult(); #else IPHostEntry host = Dns.GetHostByName(str); #endif if (host != null && host.AddressList != null && host.AddressList.Length > 0 && host.AddressList[0] != null) { return(host.AddressList[0]); } #endif } catch (Exception ex) { throw ConversionNotSupportedException.Create(typeof(IPAddress), source, ex); } } throw ConversionNotSupportedException.Create(typeof(IPAddress), source); }