如何在C＃中创建通用数字解析器？ [重复]

问题描述

|                                                                                                                   这个问题已经在这里有了答案：                                                      

解决方法

        您基本上必须使用反射来找到相关的静态

Parse

方法，将其调用，并将返回值强制转换回

T

。或者，您可以使用

Convert.ChangeType

或获取相关的

TypeDescriptor

和相关的

TypeConverter

。 一种更有限但有效（且在某些方面简单）的方法是将字典从类型保留为解析委托-将委托转换为

Func<string,T>

并调用它。这将允许您对不同的类型使用不同的方法，但是您需要知道转换为预先类型所需的类型。 无论您做什么，都将无法指定通用约束，但是该通用约束会使它在编译时很安全。确实，您需要类似我对静态接口的想法。编辑：如前所述，这里有

IConvertible

界面，但这并不一定意味着您将能够从

string

转换。另一种类型可以实现

IConvertible

，而无需从字符串转换为该类型。     ,        实际上，标准数字类型确实实现了一个公共接口：IConvertible。这是

Convert.ChangeType

使用的那个。 不幸的是，没有等效的“ 10”，如果无法解析字符串，它将抛出异常。 作为附带说明，BCL团队似乎完全忘记了整个“转换”区域。自.NET Framework 1以来，这里没有任何新内容（TryParse方法除外）。     ,        这非常骇人，但是可以使用Newtonsoft.Json（Json.NET）进行工作：

 JsonConvert.DeserializeObject<double>(\"24.11\");
 // Type == System.Double - Value: 24.11

 JsonConvert.DeserializeObject<int>(\"29.4\");
 // Type == System.Int32 - Value: 29

    ,        我编写了一些代码，这些代码使用反射来查找类型上的

Parse

/

TryParse

方法并从通用函数访问这些方法：

private static class ParseDelegateStore<T>
{
    public static ParseDelegate<T> Parse;
    public static TryParseDelegate<T> TryParse;
}

private delegate T ParseDelegate<T>(string s);
private delegate bool TryParseDelegate<T>(string s,out T result);


public static T Parse<T>(string s)
{
    ParseDelegate<T> parse = ParseDelegateStore<T>.Parse;
    if (parse == null)
    {
        parse = (ParseDelegate<T>)Delegate.CreateDelegate(typeof(ParseDelegate<T>),typeof(T),\"Parse\",true);
        ParseDelegateStore<T>.Parse = parse;
    }
    return parse(s);
}

public static bool TryParse<T>(string s,out T result)
{
    TryParseDelegate<T> tryParse = ParseDelegateStore<T>.TryParse;
    if (tryParse == null)
    {
        tryParse = (TryParseDelegate<T>)Delegate.CreateDelegate(typeof(TryParseDelegate<T>),\"TryParse\",true);
            ParseDelegateStore<T>.TryParse = tryParse;
    }
    return tryParse(s,out result);
}

https://github.com/CodesInChaos/ChaosUtil/blob/master/Chaos.Util/Conversion.cs 但是我还没有对它们进行过多的测试，因此它们可能会有些缺陷/不适用于每种类型。错误处理也有点缺乏。 对于文化不变解析，它们没有任何重载。因此，您可能需要添加它。     ,        是的，可以从字符串中解析的类型很可能具有静态的

Parse

和

TryParse

重载，您可以通过反射找到它们，如Jon建议的那样。

private static Func<string,T> GetParser<T>()
{
    // The method we are searching for accepts a single string.
    // You can add other types,like IFormatProvider to target specific overloads.
    var signature = new[] { typeof(string) };

    // Get the method with the specified name and parameters.
    var method = typeof(T).GetMethod(\"Parse\",signature);

    // Initialize the parser delegate.
    return s => (T)method.Invoke(null,new[] { s });
}

为了提高性能，您还可以构建调用它们的lambda表达式，因为

Invoke

方法将方法参数接受为

object[]

，这是不必要的分配，并且如果您的参数包括值类型，则会引起装箱。它还返回结果为

object

，当您的类型是值类型时也会引起装箱。

private static Func<string,T> GetParser<T>()
{
    // Get the method like we did before.
    var signature = new[] { typeof(string) };
    var method = typeof(T).GetMethod(\"Parse\",signature);

    // Build and compile a lambda expression.
    var param = Expression.Parameter(typeof(string));
    var call = Expression.Call(method,param);
    var lambda = Expression.Lambda<Func<string,T>>(call,param);
    return lambda.Compile();
}

调用已编译的lambda表达式本质上与调用原始解析方法本身一样快，但是首先构建和编译它却没有。这就是为什么，再次像Jon建议的那样，我们应该缓存生成的委托。 我使用静态的通用类在ValueString中缓存解析器。

private static class Parser<T>
{
    public static readonly Func<string,T> Parse = InitParser();

    private static Func<string,T> InitParser()
    {
        // Our initialization logic above.
    }
}

之后，您的解析方法可以这样写：

public static T Parse<T>(string s)
{
    return Parser<T>.Parse(s);
}