C# 如何按值对字典条目列表进行排序（自定义排序）

我的哈希表包含（键，值[]）

e、 g:

其中值1；值2、值3、值4和值5如下所示

Value1[name = "Smith"]
Value1[Title= "Mr"]
Value1[Salary = 1000]
Value1[Identity = "S"]

Value2[name = "Peter"]
Value2[Title= "Mr"]
Value2[Salary = 1000]
Value2[Identity = "A"]


Value3[name = "Tom"]
Value3[Title= "Mr"]
Value3[Salary = 1000]
Value3[Identity = "C"]


Value4[name = "Marry"]
Value4[Title= "Ms"]
Value4[Salary = 1000]
Value4[Identity = ""]

Value5[name = "Sam"]
Value5[Title= "Mr"]
Value5[Salary = 1000]
Value5[Identity = "C"]

myHashtable.Add[3, Value3]; // Value3.Identity = "C"
myHashtable.Add[5, Value5]; // Value5.Identity = "C"
myHashtable.Add[2, Value2]; // Value2.Identity = "A"
myHashtable.Add[1, Value1]; // Value1.Identity = "S"
myHashtable.Add[4, Value4]; // Value4.Identity = ""

我想排序此字典输入列表中的值，其中标识先是“C”值，然后是“A”，然后是“S”，然后是“”

排序后，结果应如下所示

Value1[name = "Smith"]
Value1[Title= "Mr"]
Value1[Salary = 1000]
Value1[Identity = "S"]

Value2[name = "Peter"]
Value2[Title= "Mr"]
Value2[Salary = 1000]
Value2[Identity = "A"]


Value3[name = "Tom"]
Value3[Title= "Mr"]
Value3[Salary = 1000]
Value3[Identity = "C"]


Value4[name = "Marry"]
Value4[Title= "Ms"]
Value4[Salary = 1000]
Value4[Identity = ""]

Value5[name = "Sam"]
Value5[Title= "Mr"]
Value5[Salary = 1000]
Value5[Identity = "C"]

myHashtable.Add[3, Value3]; // Value3.Identity = "C"
myHashtable.Add[5, Value5]; // Value5.Identity = "C"
myHashtable.Add[2, Value2]; // Value2.Identity = "A"
myHashtable.Add[1, Value1]; // Value1.Identity = "S"
myHashtable.Add[4, Value4]; // Value4.Identity = ""

这是我的尝试

var result1 = new List<DictionaryEntry>(hashtable.Count);
var result2 = new List<DictionaryEntry>(hashtable.Count);
var result3 = new List<DictionaryEntry>(hashtable.Count);                 
var result4 = new List<DictionaryEntry>(hashtable.Count);


var result = new List<DictionaryEntry>(hashtable.Count);

foreach (DictionaryEntry entry in hashtable)
   {
        result.Add(entry);
   }


                foreach (DictionaryEntry dictionaryEntry in result)
                {
                    var t2 = dictionaryEntry.Value;

                    switch (t2.Identity)
                    {
                        case "C":
                            result1.Add(dictionaryEntry);
                            break;
                        case "A":
                            result2.Add(dictionaryEntry);
                            break;
                        case "S":
                            result3.Add(dictionaryEntry);
                            break;
                        case "":
                            result4.Add(dictionaryEntry);
                            break;
                        default:
                            break;
                    }
                }
                result1.ToList();
                result2.ToList();
                result3.ToList();


                var combinedResult = result1.Union(result2)
                    .Union(result3)
                    .Union(result4)
                    .ToDictionary(k => k.Key, v => v.Value).OrderByDescending(v => v.Value);

var result1=新列表（hashtable.Count）；
var result2=新列表（hashtable.Count）；
var result3=新列表（hashtable.Count）；
var result4=新列表（hashtable.Count）；
var结果=新列表（hashtable.Count）；
foreach（哈希表中的DictionaryEntry条目）
{
结果。添加（条目）；
}
foreach（结果中的DictionaryEntry DictionaryEntry）
{
var t2=字典入口值；
开关（t2.标识）
{
案例“C”：
结果1.添加（字典输入）；
打破
案例“A”：
结果2.添加（字典输入）；
打破
案例“S”：
结果3.添加（字典输入）；
打破
案例“”：
结果4.添加（字典输入）；
打破
违约：
打破
}
}
结果1.ToList（）；
结果2.ToList（）；
结果3.ToList（）；
var combinedResult=result1.Union（result2）
.工会（结果3）
.工会（结果4）
.ToDictionary（k=>k.Key，v=>v.Value）；

如何对combinedResult进行排序以提供上述自定义排序字典条目列表

任何帮助都是非常感激的。

---

谢谢

当使用哈希表实现字典数据结构时，为了实现摊销O（1）插入/删除/更新操作，数据是未排序的。另一方面，当使用平衡树实现字典时，操作的速度要慢一些O（logn），但它们可以按排序方式（通过键）枚举。例如，C语言字典实现是不排序的，并且C++地图是基于红黑树排序的 鉴于上述情况（您不能在字典中按您所需的方式对数据进行排序），您可以将字典保存为列表/数组，然后按您所需的比较器进行排序

下面是一个字典和自定义比较器的示例，您可以从中获得字典中的值，这些值按自定义比较器中的逻辑排序：

public class Data
{
    public string Name { get; set; }
    public string Identity { get; set; }
}

public class CustomerComparer : IComparer<KeyValuePair<int, Data>>
{
    private List<string> orderedLetters = new List<string>() { "C", "A", "S" };

    public int Compare(KeyValuePair<int, Data> str1, KeyValuePair<int, Data> str2)
    {
        return orderedLetters.IndexOf(str1.Value.Identity) - orderedLetters.IndexOf(str2.Value.Identity);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Data value1 = new Data { Name = "Name1", Identity = "S" };
        Data value2 = new Data { Name = "Name2", Identity = "A" };
        Data value3 = new Data { Name = "Name3", Identity = "C" };
        Data value4 = new Data { Name = "Name4", Identity = "C" };

        Dictionary<int, Data> unsortedDictionary = new Dictionary<int, Data>();
        unsortedDictionary.Add(1, value1);
        unsortedDictionary.Add(2, value2);
        unsortedDictionary.Add(3, value3);
        unsortedDictionary.Add(4, value4);

        var customSortedValues = unsortedDictionary.Values.OrderBy(item => item, new CustomerComparer()).ToArray();

        for (int i=0; i < customSortedValues.Length; i++)
        {
            var kvp = customSortedValues[i];
            Console.WriteLine("{0}: {1}=(Name={2}, Identity={3})", i, kvp.Key, kvp.Value.Name, kvp.Value.Identity);
        }
    }
}
//Output is:  
//0: Name3=C
//1: Name4=C
//2: Name2=A
//3: Name1=S

公共类数据
{
公共字符串名称{get；set；}
公共字符串标识{get；set；}
}
公共类客户比较者：IComparer
{
private List orderedLetters=新列表（）{“C”、“A”、“S”}；
公共整数比较（KeyValuePair str1、KeyValuePair str2）
{
返回orderedLetters.IndexOf（str1.Value.Identity）-orderedLetters.IndexOf（str2.Value.Identity）；
}
}
班级计划
{
静态void Main（字符串[]参数）
{
数据值1=新数据{Name=“Name1”，Identity=“S”}；
数据值2=新数据{Name=“Name2”，Identity=“A”}；
数据值3=新数据{Name=“Name3”，Identity=“C”}；
数据值4=新数据{Name=“Name4”，Identity=“C”}；
Dictionary unsortedDictionary=新字典（）；
添加（1，值1）；
添加（2，值2）；
添加（3，值3）；
添加（4，值4）；
var customSortedValues=unsortedDictionary.Values.OrderBy（item=>item，new CustomerComparer（））.ToArray（）；
for（int i=0；i

---

您还可以使用SortedDictionary（正如@Clockwork Muse所建议的）并传递与上述示例中类似的CustomComparer。这实际上取决于您的需求。如果您需要操作保持快速，并且只需要为报告排序值，那么只需在需要值时排序（如我的示例中所示）。如果您将大量访问已排序的值，那么首先保持它们的排序可能是有意义的。

您的

案例

实际上没有任何作用，因为在它变成字典后，排序就会消失。如果需要维护排序，我可能会提供一个带有自定义比较器的实例。如果您只想对枚举的输出进行排序，请在

OrderByDescending

中进行排序。谢谢！如果输入来自具有键和值的哈希表，您将如何将输入插入Dictionary unsortedDictionary？上面示例中的Dictionary在何处？DictionaryEntry包含键和值的

对象

，因此您可以将它们转换为

Dictionary.Add（（int）DictionaryEntry.Key，（Data）DictionaryEntry.Value）

。使用哈希表有什么具体原因吗？而不是通用字典？还不确定程序为什么使用哈希表。但我正试图将输入（哈希表结果）插入到unsortedDictionary。然而，我无法将字典“Key”值转换为未排序的dictionary<代码>[Dictionary unsortedDictionary=new Dictionary（）；foreach（HashtableResult中的DictionaryEntry条目）{unsortedDictionary.Add（（int）entry.Key，（Data）entry.Value）；}var customSortedValues=unsortedDictionary.Values.OrderBy（item=>item，new Custom