C# 使用C对嵌套字典进行排序#

我有一个dictionary对象，类型如下

Dictionary<string, Dictionary<Roles, Dictionary<Period, List<Product>>>>

我得按下列顺序把字典分类

"Sachin" --> Roles.Preparer --> Period.Ahead --> Products
"Sachin" --> Roles.Approver --> Period.Ahead --> Products
"Sachin" --> Roles.Preparer --> Period.Past --> Products
"Sachin" --> Roles.Approver --> Period.Past --> Products

这个结构是必需的，因为我必须遍历每个项目，并且应该作为邮件的一部分添加

实际代码如下所示

`using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Basics
{
    class Product
    {
        public string Name { get; set; }
        public int Days { get; set; }

    }

    enum Period
    {
        Ahead,
        Past
    }

    enum Roles
    {
        Preparer,
        Approver
    }

    class Program
    {
        static void Main(string[] args)
        {
            DictionaryProcessing(new string[] { "sriram123@yahoo.com", "abhishek321@yahoo.com" });
        }

        private static void DictionaryProcessing(string[] emailIDs)
        {
            List<Product> products = new List<Product>();

            Product product1 = new Product() { Name = "Pencil", Days = 14 };
            Product product2 = new Product() { Name = "Eraser", Days = 2 };
            Product product3 = new Product() { Name = "Geometry Box", Days = 31 };

            products.Add(product1);
            products.Add(product2);
            products.Add(product3);

            Dictionary<string, Dictionary<Roles, Dictionary<Period, List<Product>>>> dict = new Dictionary<string, Dictionary<Roles, Dictionary<Period, List<Product>>>>();

            ///

            foreach (string emailID in emailIDs)
            {

                if (!dict.ContainsKey(emailID))
                    dict.Add(emailID, new Dictionary<Roles, Dictionary<Period, List<Product>>>());

                if (!dict[emailID].ContainsKey(Roles.Preparer))
                    dict[emailID].Add(Roles.Preparer, new Dictionary<Period, List<Product>>());

                if (!dict[emailID][Roles.Preparer].ContainsKey(Period.Ahead))
                    dict[emailID][Roles.Preparer].Add(Period.Ahead, new List<Product>());

                if (!dict[emailID][Roles.Preparer].ContainsKey(Period.Past))
                    dict[emailID][Roles.Preparer].Add(Period.Past, new List<Product>());

                ///

                if (!dict[emailID].ContainsKey(Roles.Approver))
                    dict[emailID].Add(Roles.Approver, new Dictionary<Period, List<Product>>());

                if (!dict[emailID][Roles.Approver].ContainsKey(Period.Ahead))
                    dict[emailID][Roles.Approver].Add(Period.Ahead, new List<Product>());

                if (!dict[emailID][Roles.Approver].ContainsKey(Period.Past))
                    dict[emailID][Roles.Approver].Add(Period.Past, new List<Product>());

                for (int i = 0; i < products.Count; i++)
                {
                    dict[emailID][Roles.Preparer][Period.Ahead].Add(products[i]);
                    dict[emailID][Roles.Preparer][Period.Past].Add(products[i]);
                    dict[emailID][Roles.Approver][Period.Past].Add(products[i]);
                    dict[emailID][Roles.Approver][Period.Ahead].Add(products[i]);
                }


            }
        }
    }
}
`

`使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
命名空间基础
{
类产品
{
公共字符串名称{get；set；}
公共整数天{get；set；}
}
枚举周期
{
向前地
过去的
}
枚举角色
{
编制人，
批准人
}
班级计划
{
静态void Main（字符串[]参数）
{
字典处理（新字符串[]{”sriram123@yahoo.com", "abhishek321@yahoo.com" });
}
专用静态无效字典处理（字符串[]EmailID）
{
列表产品=新列表（）；
product1=新产品（）{Name=“Pencil”，天数=14}；
product2=新产品（）{Name=“橡皮擦”，天数=2}；
product3=新产品（）{Name=“Geometry Box”，天数=31}；
产品。添加（产品1）；
产品。添加（产品2）；
产品。添加（产品3）；
Dictionary dict=新字典（）；
///
foreach（emailID中的字符串emailID）
{
如果（！dict.ContainsKey（emailID））
dict.Add（emailID，newdictionary（））；
如果（！dict[emailID].ContainsKey（Roles.Preparer））
dict[emailID].Add（Roles.Preparer，new Dictionary（））；
如果（！dict[emailID][Roles.Preparer].ContainsKey（Period.Ahead））
dict[emailID][Roles.Preparer].Add（Period.Ahead，new List（））；
如果（！dict[emailID][Roles.Preparer].ContainsKey（Period.pass））
dict[emailID][Roles.Preparer].Add（Period.pass，new List（））；
///
如果（！dict[emailID].ContainsKey（Roles.Approver））
dict[emailID].Add（Roles.Approver，new Dictionary（））；
如果（！dict[emailID][Roles.Approver].ContainsKey（Period.Ahead））
dict[emailID][Roles.Approver].Add（Period.Ahead，new List（））；
如果（！dict[emailID][Roles.Approver].ContainsKey（Period.pass））
dict[emailID][Roles.Approver].Add（Period.pass，new List（））；
对于（int i=0；i

---

我怎样才能按这个顺序分类呢我仅限于使用.NET 2.0 framework。

无法对词典进行排序。它们不是列表。此外：

您的结构不好-字典不能多次包含同一个键，因此您提供的示例甚至无法创建：

"Sachin" --> Roles.Preparer --> Period.Past --> Products
"Sachin" --> Roles.Approver --> Period.Ahead --> Products
"Sachin" --> Roles.Approver --> Period.Ahead --> Products
"Sachin" --> Roles.Approver --> Period.Past --> Products

“外部”词典不能多次包含键“Sachin”。“内部字典”不能多次包含角色

审批人

，也不能包含最后一级

期间。过去/未来

不能多次为键

改为将结构更改为

List

，其中

T

是一个合适的数据结构，或者，正如其他人已经指出的，现在更改为类型化数据集，将结构视为一个表

编辑
我现在正在编辑我的答案，只是为了确保我们都明白每个人都在谈论什么

我是说，一本字典不可能有两个相同的键。因此，根据这条规则，您的案例必须减少到以下情况：

"Sachin" --> Roles.Preparer --> Period.Past --> Products
"Sachin" --> Roles.Approver --> Period.Ahead --> Products
"Sachin" --> Roles.Approver --> Period.Past --> Products

现在我们正在讨论一些适用于规则的东西，我们可以问“如何排序？”。答案是：你不能。根据定义，字典是一种无序结构。但是，您可以确保按特定顺序检索值。如果要对产品进行“排序”，以便

过去的

产品始终位于

前面的

产品之前，只需确保先使用相应的键即可

编辑2

刚刚意识到这是基于复制/粘贴错误。您正在谈论的数据应该是：

"Sachin" --> Roles.Preparer --> Period.Ahead --> Products
"Sachin" --> Roles.Preparer --> Period.Past --> Products
"Sachin" --> Roles.Approver --> Period.Past --> Products
"Sachin" --> Roles.Approver --> Period.Ahead --> Products

您说过您正在使用此代码添加项目：

for (int i = 0; i < products.Count; i++)
{
    dict[emailID][Roles.Preparer][Period.Ahead].Add(products[i]);
    dict[emailID][Roles.Preparer][Period.Past].Add(products[i]);
    dict[emailID][Roles.Approver][Period.Past].Add(products[i]);
    dict[emailID][Roles.Approver][Period.Ahead].Add(products[i]);
}

for（int i=0；i

然后您可以使用类似的代码来检索项目。给定一个电子邮件ID，以下内容将为您提供按“批准人之前的准备人”和“批准人之前的过去”排序的项目列表：

List productsForEMailID=new List（）；
productsForEMailID.AddRange（dict[emailID][Roles.Preparer][Period.pass]）；
productsForEMailID.AddRange（dict[emailID][Roles.Approver][Period.pass]）；
productsForEMailID.AddRange（dict[emailID][Roles.Preparer][Period.Ahead]）；
productsForEMailID.AddRange（dict[emailID][Roles.Approver][Period.Ahead]）；

---

产品列表已“排序”。

您可以使用另一种更适合此问题的密钥类型。如果您想快速破解

分类词典

：

这里我假设名称中不能出现“#”字符。第一个数字表示

角色

为

编制者=0

，

审批者=1

，第二个数字表示

期间

为

提前=0

，

过去=1

或者-如果您需要更强健的解决方案，

for (int i = 0; i < products.Count; i++)
{
    dict[emailID][Roles.Preparer][Period.Ahead].Add(products[i]);
    dict[emailID][Roles.Preparer][Period.Past].Add(products[i]);
    dict[emailID][Roles.Approver][Period.Past].Add(products[i]);
    dict[emailID][Roles.Approver][Period.Ahead].Add(products[i]);
}

List<Product> productsForEMailID = new List<Product>();

productsForEMailID.AddRange(dict[emailID][Roles.Preparer][Period.Past]);
productsForEMailID.AddRange(dict[emailID][Roles.Approver][Period.Past]);
productsForEMailID.AddRange(dict[emailID][Roles.Preparer][Period.Ahead]);
productsForEMailID.AddRange(dict[emailID][Roles.Approver][Period.Ahead]);

"Sachin#0#0" --> Products
"Sachin#0#1" --> Products
...

public struct Key : IComparable<Key>
{
    public String Name;
    public Roles Role;
    public Period Period;

    public int CompareTo(Key other)
    {
        var c = String.Compare(Name, other.Name, StringComparison.Ordinal);
        if (c != 0) return c;
        c = Role.CompareTo(other.Role);
        if (c != 0) return c;
        return Period.CompareTo(other.Period);
    }
}