Ejemplo n.º 1
0
        /// <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);
        }
Ejemplo n.º 2
0
        /// <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);
        }
Ejemplo n.º 3
0
        /// <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);
        }
Ejemplo n.º 4
0
        /// <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);
        }
Ejemplo n.º 5
0
        /// <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);
        }
Ejemplo n.º 6
0
        /// <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);
        }
Ejemplo n.º 7
0
        /// <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);
        }