/// <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
{
// 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]);
}
}
catch (Exception ex)
{
throw ConversionNotSupportedException.Create(typeof(IPAddress), source, ex);
}
}
throw ConversionNotSupportedException.Create(typeof(IPAddress), source);
}
public object ConvertFrom(object source)
{
string ipString = source as string;
if ((ipString != null) && (ipString.Length > 0))
{
try
{
IPAddress address;
if (!IPAddress.TryParse(ipString, out address))
{
IPHostEntry hostEntry = Dns.GetHostEntry(ipString);
if (((hostEntry != null) && ((hostEntry.AddressList != null) && (hostEntry.AddressList.Length > 0))) && (hostEntry.AddressList[0] != null))
{
return(hostEntry.AddressList[0]);
}
}
else
{
return(address);
}
}
catch (Exception exception)
{
throw ConversionNotSupportedException.Create(typeof(IPAddress), source, exception);
}
}
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="M:System.Net.IPAddress.Parse(System.String)" /> method to convert the
/// <see cref="T:System.String" /> argument to an <see cref="T:System.Net.IPAddress" />.
/// If that fails then the string is resolved as a DNS hostname.
/// </para>
/// </remarks>
/// <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
/// The <paramref name="source" /> object cannot be converted to the
/// target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.IPAddressConverter.CanConvertFrom(System.Type)" />
/// method.
/// </exception>
public object ConvertFrom(object source)
{
string text = source as string;
if (text != null && text.Length > 0)
{
try
{
if (text.Trim(validIpAddressChars).Length == 0)
{
try
{
return(IPAddress.Parse(text));
}
catch (FormatException)
{
}
}
IPHostEntry result = Dns.GetHostEntryAsync(text).GetAwaiter().GetResult();
if (result != null && result.AddressList != null && result.AddressList.Length != 0 && result.AddressList[0] != null)
{
return(result.AddressList[0]);
}
}
catch (Exception innerException)
{
throw ConversionNotSupportedException.Create(typeof(IPAddress), source, innerException);
}
}
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 !NETCF
// 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]);
}
}
catch (Exception ex)
{
throw ConversionNotSupportedException.Create(typeof(IPAddress), source, ex);
}
}
throw ConversionNotSupportedException.Create(typeof(IPAddress), source);
}
public object ConvertFrom(object source)
{
string pattern = source as string;
if (pattern == null)
{
throw ConversionNotSupportedException.Create(typeof(PatternString), source);
}
return(new PatternString(pattern));
}
/// <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="M:System.Boolean.Parse(System.String)" /> method to convert the
/// <see cref="T:System.String" /> argument to a <see cref="T:System.Boolean" />.
/// </para>
/// </remarks>
/// <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
/// The <paramref name="source" /> object cannot be converted to the
/// target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.BooleanConverter.CanConvertFrom(System.Type)" />
/// method.
/// </exception>
public object ConvertFrom(object source)
{
string text = source as string;
if (text != null)
{
return(bool.Parse(text));
}
throw ConversionNotSupportedException.Create(typeof(bool), source);
}
public object ConvertFrom(object source)
{
string typeName = source as string;
if (typeName == null)
{
throw ConversionNotSupportedException.Create(typeof(Type), source);
}
return(SystemInfo.GetTypeFromString(typeName, true, true));
}
/// <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="T:System.String" /> argument to a <see cref="T:System.Type" />.
/// Additional effort is made to locate partially specified types
/// by searching the loaded assemblies.
/// </para>
/// </remarks>
/// <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
/// The <paramref name="source" /> object cannot be converted to the
/// target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.TypeConverter.CanConvertFrom(System.Type)" />
/// method.
/// </exception>
public object ConvertFrom(object source)
{
string text = source as string;
if (text != null)
{
return(SystemInfo.GetTypeFromString(GetType().GetTypeInfo().Assembly, text, throwOnError: true, ignoreCase: true));
}
throw ConversionNotSupportedException.Create(typeof(Type), source);
}
public object ConvertTo(object source, Type targetType)
{
PatternString str = source as PatternString;
if ((str == null) || !this.CanConvertTo(targetType))
{
throw ConversionNotSupportedException.Create(targetType, source);
}
return(str.Format());
}
/// <summary>
/// Overrides the ConvertFrom method of IConvertFrom.
/// </summary>
/// <param name="source">the object to convert to an encoding</param>
/// <returns>the encoding</returns>
/// <remarks>
/// <para>
/// Uses the <see cref="M:Encoding.GetEncoding(string)"/> method to
/// convert the <see cref="String"/> argument to an <see cref="Encoding"/>.
/// </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(Encoding.GetEncoding(str));
}
throw ConversionNotSupportedException.Create(typeof(Encoding), source);
}
/// <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="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)
{
var patternString = source as PatternString;
if (patternString != null && CanConvertTo(targetType))
{
return(patternString.Format());
}
throw ConversionNotSupportedException.Create(targetType, source);
}
public object ConvertFrom(object source)
{
string name = source as string;
if (name == null)
{
throw ConversionNotSupportedException.Create(typeof(Encoding), source);
}
return(Encoding.GetEncoding(name));
}
public object ConvertFrom(object source)
{
string str = source as string;
if (str == null)
{
throw ConversionNotSupportedException.Create(typeof(bool), source);
}
return(bool.Parse(str));
}
/// <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)
{
var 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 a Type</param>
/// <returns>the Type</returns>
/// <remarks>
/// <para>
/// Uses the <see cref="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)
{
var str = source as string;
if (str != null)
{
return(SystemInfo.GetTypeFromString(str, true, true));
}
throw ConversionNotSupportedException.Create(typeof(Type), source);
}
/// <summary>
/// Overrides the ConvertFrom method of IConvertFrom.
/// </summary>
/// <param name="source">the object to convert to a PatternLayout</param>
/// <returns>the PatternLayout</returns>
/// <remarks>
/// <para>
/// Creates and returns a new <see cref="T:log4net.Layout.PatternLayout" /> using
/// the <paramref name="source" /> <see cref="T:System.String" /> as the
/// <see cref="P:log4net.Layout.PatternLayout.ConversionPattern" />.
/// </para>
/// </remarks>
/// <exception cref="T:log4net.Util.TypeConverters.ConversionNotSupportedException">
/// The <paramref name="source" /> object cannot be converted to the
/// target type. To check for this condition use the <see cref="M:log4net.Util.TypeConverters.PatternLayoutConverter.CanConvertFrom(System.Type)" />
/// method.
/// </exception>
public object ConvertFrom(object source)
{
string text = source as string;
if (text != null)
{
return(new PatternLayout(text));
}
throw ConversionNotSupportedException.Create(typeof(PatternLayout), 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>
/// 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)
{
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);
}
