C# 用于分析对象的通用函数

将字符串解析为从参数获取的类型的最佳方法是什么

我目前正在使用以下函数解析XML节点，但希望使其具有通用性

    private void ParseSettings(XmlDocument doc)
    {
        IsFormVisible = (bool) ParseNode(doc, "Settings/IsFormVisible", IsFormVisible);
        UpdaterRunInterval = (int) ParseNode(doc, "Settings/UpdaterRunInterval", UpdaterRunInterval);
        UpdaterLastRunTime = (DateTime) ParseNode(doc, "Settings/UpdaterLastRunTime", UpdaterLastRunTime);
    }

    private object ParseNode(XmlDocument doc, string node, object defaultValue)
    {
        try
        {
            XmlNode xmlNode = doc.SelectSingleNode(node);
            if (xmlNode == null)
                return defaultValue;
            string text = xmlNode.InnerText;
            if (defaultValue is int)
                return int.Parse(text);
            if (defaultValue is bool)
                return bool.Parse(text);
            if (defaultValue is string)
                return text;
            if (defaultValue is DateTime)
                return DateTime.Parse(text);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        return defaultValue;
    }

尝试以下方法：

private static T ParseNode<T>(XmlDocument doc, string node, object defaultValue)
{
    object ret = defaultValue;
    try
    {

        XmlNode xmlNode = doc.SelectSingleNode(node);
        if (xmlNode == null)
            return default(T);
        string text = xmlNode.InnerText;
        if (defaultValue is int)
            ret = int.Parse(text);
        if (defaultValue is bool)
            ret =  bool.Parse(text);
        if (defaultValue is string)
            ret = text;
        if (defaultValue is DateTime)
            ret = DateTime.Parse(text);

        return (T) ret;
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
    return (T)ret;
}

private static T ParseNode（XmlDocument doc，string节点，object defaultValue）
{
对象ret=默认值；
尝试
{
XmlNode XmlNode=doc.SelectSingleNode（节点）；
if（xmlNode==null）
返回默认值（T）；
string text=xmlNode.InnerText；
如果（默认值为int）
ret=int.Parse（文本）；
如果（默认值为bool）
ret=bool.Parse（文本）；
如果（默认值为字符串）
ret=文本；
如果（默认值为DateTime）
ret=DateTime.Parse（文本）；
返回（T）ret；
}
捕获（例外情况除外）
{
控制台写入线（例如消息）；
}
返回（T）ret；
}

我不能保证，这是一个完美的方式做它，但它的工作

    IsFormVisible = ParseNode<bool>(doc, "Settings/IsFormVisible", true);
    UpdaterRunInterval = ParseNode<int>(doc, "Settings/UpdaterRunInterval", 1);
    UpdaterLastRunTime = ParseNode<DateTime>(doc, "Settings/UpdaterLastRunTime", 1);

IsFormVisible=ParseNode（doc，“设置/IsFormVisible”，true）；
UpdaterRuntVal=ParseNode（文档，“设置/UpdaterRuntVal”，1）；
UpdaterAstruntime=ParseNode（文档“设置/UpdaterAstruntime”，1）；

私有T ParseNode（XmlDocument文档，字符串节点，T defaultValue）
{
尝试
{
XmlNode XmlNode=doc.SelectSingleNode（节点）；
if（xmlNode==null）
返回默认值；
string text=xmlNode.InnerText；
返回SafeConvert（文本，默认值）；
}
捕获（例外情况除外）
{
控制台写入线（例如消息）；
}
返回默认值；
}
公共静态T SafeConvert（字符串s，T defaultValue）
{
if（string.IsNullOrEmpty）
返回默认值；
return（T）Convert.ChangeType（s，typeof（T））；
}

如果你不认为你可以这样做。我认为您最好使用int.TryPares、bool.TryParse等，如果它们不解析，则返回相应的错误消息。我故意返回默认值，以便重新创建损坏或丢失的节点。我只是不喜欢这样，必须检查类型并为每个类型调用Parse。@miroslavpov-chk答案！即使将方法设置为泛型，您仍然必须检查类型。没有where子句可以应用于泛型方法，在泛型方法中可以执行类似于T.TryParse的操作，因为没有包含所有这些类型共享的Parse或TryParse的基类。

private T ParseNode<T>(XmlDocument doc, string node, T defaultValue)
{
    try
    {
        XmlNode xmlNode = doc.SelectSingleNode(node);
        if (xmlNode == null)
            return defaultValue;
        string text = xmlNode.InnerText;
        return SafeConvert(text, defaultValue);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex.Message);
    }
    return defaultValue;
}

public static T SafeConvert<T>(string s, T defaultValue)
{
    if ( string.IsNullOrEmpty(s) )
        return defaultValue;
    return (T)Convert.ChangeType(s, typeof(T));
}