गतिशील रूप से TryParse को कैसे कॉल करें?

Question

क्या TryParse गतिशील रूप से कॉल करने का कोई तरीका है? कुछ प्रकार:

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

बेशक कोई इसके लिए टाइपऑनटर का उपयोग कर सकता है। हालांकि, एक अवैध रूपांतरण के परिणामस्वरूप अपवाद होगा और मैं इससे छुटकारा पाना चाहता हूं।

Answer 1

आप प्रतिबिंब का उपयोग करके गतिशील रूप से TryParse विधि को कॉल कर सकते हैं। यदि रूपांतरण विफल रहता है तो इस तरह आपको समय लेने वाली अपवाद नहीं मिलेगी।

यह विधि इस 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

आप कुछ इस तरह लिख सकते हैं:

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); 
} 

और फिर इसे पसंद फोन:

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

मैं वास्तव में इस की सिफारिश नहीं होगा जब तक आप कुछ परिदृश्य है कि यह आवश्यकता है।