6

我正在使用以下方法来提供对各种 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 员工和我本人将收到警报。

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

4

4 回答 4

8

不，这些方法基本上是完全独立的 - 编译器不知道它与etcDateTime.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 服务的传入数据，我强烈建议您改用不变文化。（就我个人而言，我也不会默默地忽略不良数据，但我认为这是故意的。）

于 2013-01-29T19:51:46.860 回答
2 
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);
于 2013-01-29T19:52:42.100 回答
2

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

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

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

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

警告 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;
        }
    }
于 2013-01-30T20:34:36.353 回答
0

这是我有时使用的一种方法。如果性能是一个主要问题，那么这不是要走的路，因为 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;
}
于 2013-01-29T19:59:09.277 回答