¿Cómo llamar a TryParse de forma dinámica?

Question

¿Hay alguna manera de llamar al TryParse de forma dinámica? Algún tipo de:

public static bool TryParse<T>(string toConvert, out T result) 

Por supuesto uno puede usar Typeonverters para esto. Sin embargo, una conversión inválida dará como resultado una excepción y quiero deshacerme de esto.

Answer 1

Puede llamar al método TryParse dinámicamente con Reflection. De esta forma, no obtendrá una Excepción lenta si la conversión falla.

Este método es una versión ligeramente optimizada de este one.

//Try Parse using Reflection 
public static bool TryConvertValue<T>(string stringValue, out T convertedValue) 
{ 
    var targetType = typeof(T); 
    if (targetType == typeof(string)) 
    { 
     convertedValue = (T)Convert.ChangeType(stringValue, typeof(T)); 
     return true; 
    } 
     var nullableType = targetType.IsGenericType && 
         targetType.GetGenericTypeDefinition() == typeof (Nullable<>); 
    if (nullableType) 
    { 
     if (string.IsNullOrEmpty(stringValue)) 
     { 
      convertedValue = default(T); 
      return true; 
     } 
      targetType = new NullableConverter(targetType).UnderlyingType; 
    } 

    Type[] argTypes = { typeof(string), targetType.MakeByRefType() }; 
    var tryParseMethodInfo = targetType.GetMethod("TryParse", argTypes); 
    if (tryParseMethodInfo == null) 
    { 
     convertedValue = default(T); 
     return false; 
    } 

    object[] args = { stringValue, null }; 
    var successfulParse = (bool)tryParseMethodInfo.Invoke(null, args); 
    if (!successfulParse) 
    { 
     convertedValue = default(T); 
     return false; 
    } 

    convertedValue = (T)args[1]; 
    return true; 
} 

Answer 2

Puede escribir algo como esto:

public delegate bool TryParser<T>(string input, out T result); 

public static bool TryParse<T> 
    (string toConvert, out T result, TryParser<T> tryParser = null) 
{ 
    if (toConvert == null) 
     throw new ArgumentNullException("toConvert"); 

    // This whole block is only if you really need 
    // it to work in a truly dynamic way. You can additionally consider 
    // memoizing the default try-parser on a per-type basis. 
    if (tryParser == null) 
    { 
     var method = typeof(T).GetMethod 
       ("TryParse", new[] { typeof(string), typeof(T).MakeByRefType() }); 

     if (method == null) 
      throw new InvalidOperationException("Type does not have a built in try-parser."); 

     tryParser = (TryParser<T>)Delegate.CreateDelegate 
      (typeof(TryParser<T>), method); 
    } 

    return tryParser(toConvert, out result); 
} 

Y luego llamar así:

int result; 
bool success = TryParse("123", out result); 

Realmente no recomendaría esto a menos que tenga algún escenario que lo requiera.