C# 将不同类型字典的重载合并到一个函数中

我需要一个帮助函数来将类似

“1=alice；2=bob；3=charlie”

的字符串转换为

字典，并将类似
“1=true；2=false；3=true”
的字符串转换为
字典，等等

为此，我编写了许多辅助函数，它们基本上是相互复制和粘贴的：

    private static void load(Dictionary<int, string> dict, string s)
    {
        dict.Clear();
        string[] items = s.Split(';');
        foreach (string item in items)
        {
            if (item.Contains("="))
            {
                string[] kv = item.Split('=');
                dict[int.Parse(kv[0])] = kv[1];
            }
        }
    }

    private static void load(Dictionary<int, bool> dict, string s)
    {
        dict.Clear();
        string[] items = s.Split(';');
        foreach (string item in items)
        {
            if (item.Contains("="))
            {
                string[] kv = item.Split('=');
                dict[int.Parse(kv[0])] = bool.Parse(kv[1]);
            }
        }
    }

    private static void load(Dictionary<int, int> dict, string s)
    {
        dict.Clear();
        string[] items = s.Split(';');
        foreach (string item in items)
        {
            if (item.Contains("="))
            {
                string[] kv = item.Split('=');
                dict[int.Parse(kv[0])] = int.Parse(kv[1]);
            }
        }
    }

private静态无效加载（字典dict，字符串s）
{
格言（Clear）；
string[]items=s.Split（“；”）；
foreach（项中的字符串项）
{
如果（项包含（“=”））
{
字符串[]kv=项。拆分（'='）；
dict[int.Parse（kv[0]）]=kv[1]；
}
}
}
专用静态无效负载（字典dict dict，字符串s）
{
格言（Clear）；
string[]items=s.Split（“；”）；
foreach（项中的字符串项）
{
如果（项包含（“=”））
{
字符串[]kv=项。拆分（'='）；
dict[int.Parse（kv[0]）]=bool.Parse（kv[1]）；
}
}
}
专用静态无效负载（字典dict dict，字符串s）
{
格言（Clear）；
string[]items=s.Split（“；”）；
foreach（项中的字符串项）
{
如果（项包含（“=”））
{
字符串[]kv=项。拆分（'='）；
dict[int.Parse（kv[0]）]=int.Parse（kv[1]）；
}
}
}

在其他数据类型上，如
long
、
DateTime
等，还有更多的数据类型

有没有办法只使用一个helper函数？我尝试了
字典
，但它不起作用。
是的，您应该使用通用方法。就我个人而言，我会让它返回一本新词典，而不是清除一本现有词典，请注意。。。并使用LINQ实现它：

private static Dictionary<int, T> Load<T>(string text, Func<string, T> parser)
{
    return s.Split(';')
            .Where(item => item.Contains("="))
            .Select(item => item.Split('=', 2))
            .ToDictionary(pair => int.Parse(pair[0]), pair => parser(pair[1]));
}

私有静态字典加载（字符串文本，Func解析器）
{
返回s.Split（“；”）
.Where（item=>item.Contains（“=”））
.Select（item=>item.Split（'='，2））
.ToDictionary（pair=>int.Parse（pair[0]），pair=>parser（pair[1]）；
}

然后用以下词语来称呼它：

Dictionary<int, int> foo = Load(text, int.Parse);
Dictionary<int, bool> bar = Load(text, bool.Parse);
Dictionary<int, string> baz = Load(text, x => x);

Dictionary foo=Load（text，int.Parse）；
字典条=加载（文本，bool.Parse）；
字典baz=Load（文本，x=>x）；
您可以将其设置为泛型并使用，它将尝试将任何字符串输入解析为输出类型：

private static void load<T>(Dictionary<int, T> dict, string s)
{
    dict.Clear();
    string[] items = s.Split(';');
    foreach (string item in items)
    {
        if (item.Contains("="))
        {
            string[] kv = item.Split('=');
            dict[int.Parse(kv[0])] = (T)Convert.ChangeType(kv[1], typeof(T));
        }
    }
}

private静态无效加载（字典dict，字符串s）
{
格言（Clear）；
string[]items=s.Split（“；”）；
foreach（项中的字符串项）
{
如果（项包含（“=”））
{
字符串[]kv=项。拆分（'='）；
dict[int.Parse（kv[0]）]=（T）Convert.ChangeType（kv[1]，typeof（T））；
}
}
}