C# 中 TryParse() 的通用包装器

Question

我正在使用以下方法来提供对各种 Type 类的 TryParse() 方法的快速内联访问。基本上，如果可能，我希望能够解析来自 Web 服务的字符串，否则返回默认值。

private Int64 Int64Parse(string value) {
    Int64 result;
    if (!Int64.TryParse(value, out result)) { return default(Int64); }
    return result;
}

private DateTime DateTimeParse(string value) {
    DateTime result;
    if (!DateTime.TryParse(value, out result)) { return default(DateTime); }
    return result;
}

private Decimal DecimalParse(string value) {
    Decimal result;
    if (!Decimal.TryParse(value, out result)) { return default(Decimal); }
    return result;
}

这些是非常重复的，对我来说，暗示可能有一种方法可以将它们包装成一个通用方法。

我被困在以下但不知道如何继续或如何搜索如何继续。

private T ParseString<T>(string value) {
    T result;
    if (!T.TryParse(value, out result)) { return default(T); }
    return result;
}

任何帮助将不胜感激。 谢谢。

==编辑== 添加一些上下文。这适用于从特定信用卡计费公司接收回发的听众。我没有在这一步进行验证，因为稍后会在业务规则步骤中进行验证。例如，我不在乎 bank_batch_number 是以 int、string 还是冻干啮齿动物的形式出现的；如果我不能干净地记录我不使用的字段，我不会因异常而停止。我确实关心我们的数据库中存在 ext_product_id 并且在消息中具有与 currency_amount_settled 匹配的价格；如果该测试失败，则交易将被搁置，并记录一个警告，并且我们的 CS 人员和我自己都会收到警报。

下面提到的文化是明智的建议。

Answer 1

不，这些方法基本上是完全独立的——编译器不知道DateTime.TryParse 与Int64.TryParse 等有任何相似之处。

您可以创建一个Dictionary<Type, Delegate> 以从目标类型映射到方法，然后编写如下内容：

private delegate bool Parser<T>(string value, out T result);

private T Parse<T>(string value) where T : struct
{
    // TODO: Validate that typeof(T) is in the dictionary
    Parser<T> parser = (Parser<T>) parsers[typeof(T)];
    T result;
    parser(value, out result);
    return result;
}

您可以像这样填充字典：

static readonly Dictionary<Type, Delegate> Parsers = CreateParsers();    

static Dictionary<Type, Delegate> CreateParsers()
{
    var parsers = new Dictionary<Type, Delegate>();
    AddParser<DateTime>(parsers, DateTime.TryParse);
    AddParser<Int64>(parsers, Int64.TryParse);
    return parsers;
}

static void AddParser<T>(Dictionary<Type, Delegate> parsers, Parser<T> parser)
{
    parsers[typeof(T)] = parser;
}

注意TryParse 模式声明out 参数的值无论如何都是该类型的默认值，因此您不需要条件逻辑。这意味着即使是重复的方法也可以变得更简单：

private static Decimal DecimalParse(string value) {
    Decimal result;
    Decimal.TryParse(value, out result);
    return result;
}

顺便说一句，请注意默认情况下TryParse 模式将使用线程的当前文化。如果这是用于解析来自 Web 服务的传入数据，我强烈建议您改用不变文化。 （我个人也不会默默地忽略不良数据，但我认为这是故意的。）

Answer 2

为什么不直接使用简单的扩展方法？

Jon Skeet 关于仅使用来自各种 TryParse 方法的默认结果的回答很好。不过， 仍然是扩展方法的一个不错的方面。如果你经常这样做，你可以在调用代码中用一行代码而不是三行代码完成同样的事情（加上可选地指定一个显式默认值）。

-- 编辑 -- 我确实意识到，在我最初的回答中，我基本上只是提供了一种稍微不同的方式来做作者已经在做的事情。我今天早些时候发现了这个问题，当时我真的很忙，认为委托和自定义解析器的东西看起来可能有点多，然后在没有真正花时间完全理解问题的情况下给出了一个答案曾是。对不起。

以下如何使用（重载）扩展方法和反射？参考https://stackoverflow.com/a/4740544/618649

Caveat Emptor：我的示例没有说明您尝试转换没有 TryParse 方法的类型。 GetMethod 调用周围应该有一些异常处理，等等。

/* The examples generates this output when run:

0
432123
-1
1/1/0001 12:00:00 AM
1/1/1970 12:00:00 AM
1/30/2013 12:00:00 PM
-1
12342.3233443

*/


class Program
    {
    static void Main ( string[] args )
        {
        Debug.WriteLine( "blah".Parse<Int64>() );
        Debug.WriteLine( "432123".Parse<long>() );
        Debug.WriteLine( "123904810293841209384".Parse<long>( -1 ) );

        Debug.WriteLine( "this is not a DateTime value".Parse<DateTime>() );
        Debug.WriteLine( "this is not a DateTime value".Parse<DateTime>( "jan 1, 1970 0:00:00".Convert<DateTime>() ) );
        Debug.WriteLine( "2013/01/30 12:00:00".Parse<DateTime>() );

        Debug.WriteLine( "this is not a decimal value".Parse<decimal>( -1 ) );
        Debug.WriteLine( "12342.3233443".Parse<decimal>() );
        }
    }

static public class Extensions
    {
    static private Dictionary<Type,MethodInfo> s_methods = new Dictionary<Type, MethodInfo>();

    static public T Parse<T> ( this string value ) where T : struct
        {
        return value.Parse<T>( default( T ) );
        }

    static public T Parse<T> ( this string value, T defaultValue ) where T : struct
        {
        // *EDITED* to cache the Reflection lookup--NOT thread safe
        MethodInfo m = null;
        if ( s_methods.ContainsKey( typeof( T ) ) )
            {
            m = s_methods[ typeof( T ) ];
            }
        else
            {
            m = typeof( T ).GetMethod(
                 "TryParse"
                 , BindingFlags.Public | BindingFlags.Static
                 , Type.DefaultBinder
                 , new[] { typeof( string ), typeof( T ).MakeByRefType() }
                 , null
                 );
            s_methods.Add( typeof( T ), m );
            }

        var args = new object[] { value, null };
        if( (bool)m.Invoke( null, args ))
            {
            return (T) args[ 1 ];
            }
        return defaultValue;
        }
    }

Answer 3

public delegate bool TryParseDelegate<T>(string str, out T value);

public static T ParseOrDefault<T>(string str, TryParseDelegate<T> parse)
{
    T value;
    return parse(str, out value) ? value : default(T);
}

你可以这样称呼它：

long l = ParseOrDefault<long>("12345", long.TryParse);

Answer 4

这是我有时使用的一种方法。如果性能是一个主要问题，那么这不是要走的路，因为 try-catch 块和对 ChangeType 的调用会比特定类型的 TryParse 减慢你的速度。

public static bool TryFromString<T>(string value, out T convertedValue)
{
    Type t = typeof(T);
    convertedValue = default(T);
    if (t.Name == "Nullable`1")
        t = System.Nullable.GetUnderlyingType(t);
    if (value != null)
    {
        try
        {
            convertedValue = (T)System.Convert.ChangeType(value, t, CultureInfo.CurrentCulture);
            return true;
        }
        catch
        {
        }
    }
    return false;
}