C# 如何在Dictionary对象中进行排序_C#_.net

C# 如何在Dictionary对象中进行排序

c# .net

C# 如何在Dictionary对象中进行排序,c#,.net,C#,.net,我正在使用C#中的Dictionary对象。我在那里有各种各样的数据，但是现在我想给它一个特定的值（double）进行升序排序如何定义词典： Dictionary<int, Dictionary<string, string>> myDict = getDictData(nr); 我不知道我是否写得很好，为了澄清我是这样称呼这个名字的： myDict[1]["name"] 所以我要做的是对这个对象进行排序，使第一个（myDict[0]）包含具有最低“number”

我正在使用C#中的Dictionary对象。我在那里有各种各样的数据，但是现在我想给它一个特定的值（double）进行升序排序

如何定义词典：

Dictionary<int, Dictionary<string, string>> myDict = getDictData(nr);

我不知道我是否写得很好，为了澄清我是这样称呼这个名字的：

myDict[1]["name"]

所以我要做的是对这个对象进行排序，使第一个（myDict[0]）包含具有最低“number”值的对象

我试着在网上查找，但我能找到的只是如何按第一个键/值排序，当然是零myDict[0]

你可以理解，我没走多远。也许你能帮我一点忙

这就是我迄今为止所尝试的：

foreach (var item in myDict.OrderBy(i => i.Key))
{
      Console.WriteLine(item);
}

或者这个：

var items = from pair in myDict orderby pair.Value ascending select pair;

或者这个：

myDict.Sort（（x，y）=>x.waterDepth.CompareTo（y.waterDepth））
什么都没用
任何帮助都将不胜感激
一本字典
没有按顺序保存，也没有明确的顺序。这是因为它是使用哈希算法实现的
虽然有一个可用的，但它看起来不适合你想要的
相反，您应该使用字典列表，并使用自定义比较器对其进行排序：
using System;
using System.Collections.Generic;

namespace ConsoleApplication2
{
    using StrStrDict = Dictionary<string, string>;

    public sealed class CustomComparer: IComparer<StrStrDict>
    {
        public int Compare(StrStrDict lhs, StrStrDict rhs)
        {
            double x = Double.Parse(lhs["number"]);
            double y = Double.Parse(rhs["number"]);

            return x.CompareTo(y);
        }
    }

    internal class Program
    {
        private static void Main()
        {
            var dict1 = new StrStrDict
            {
                {"name",   "name1"},
                {"number", "0.0158"}
            };

            var dict2 = new StrStrDict
            {
                {"name",   "name2"},
                {"number", "0.0038"}
            };

            var dict3 = new StrStrDict
            {
                {"name",   "name3"},
                {"number", "0.0148"}
            };

            var list = new List<StrStrDict> {dict1, dict2, dict3};

            list.Sort(new CustomComparer());

            foreach (var element in list)
            {
                Console.WriteLine("Number = " + element["number"]);
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
命名空间控制台应用程序2
{
使用StrStrDict=字典；
公共密封类CustomComparer:IComparer
{
公共整数比较（StrStrDict lhs、STRSTRSTRDICT rhs）
{
double x=double.Parse（lhs[“number”]）；
double y=double.Parse（rhs[“number”]）；
返回x.CompareTo（y）；
}
}
内部课程计划
{
私有静态void Main（）
{
var dict1=新的StrStrDict
{
{“name”，“name1”}，
{“数字”，“0.0158”}
};
var dict2=新的StrStrDict
{
{“name”，“name2”}，
{“数字”，“0.0038”}
};
var dict3=新的StrStrDict
{
{“name”，“name3”}，
{“数字”，“0.0148”}
};
var list=新列表{dict1，dict2，dict3}；
排序（new CustomComparer（））；
foreach（列表中的var元素）
{
Console.WriteLine（“Number=“+element[“Number”]）；
}
}
}
}

请注意，这与您的示例不太相似，因为您似乎存储的是实际的double，而不是double的字符串表示形式，但这与您对字典的使用不匹配。因此，我将它们存储为字符串，并根据需要将它们解析为double。这不是很有效，另一种方法是使用字典
并在比较器中强制转换值-参见后面的示例
还要注意，我根本没有添加任何错误处理
下面是一个使用字典的示例：
using System;
using System.Collections.Generic;

namespace ConsoleApplication2
{
    using StrObjDict = Dictionary<string, object>;

    public sealed class CustomComparer: IComparer<StrObjDict>
    {
        public int Compare(StrObjDict lhs, StrObjDict rhs)
        {
            double x = (double)lhs["number"];
            double y = (double)rhs["number"];

            return x.CompareTo(y);
        }
    }

    internal class Program
    {
        private static void Main()
        {
            var dict1 = new StrObjDict
            {
                {"name",   "name1"},
                {"number", 0.0158}
            };

            var dict2 = new StrObjDict
            {
                {"name",   "name2"},
                {"number", 0.0038}
            };

            var dict3 = new StrObjDict
            {
                {"name",   "name3"},
                {"number", 0.0148}
            };

            var list = new List<StrObjDict> {dict1, dict2, dict3};

            list.Sort(new CustomComparer());

            foreach (var element in list)
            {
                Console.WriteLine("Name = {0}, Number = {1}", element["name"], element["number"]);
            }
        }
    }
}

使用系统；
使用System.Collections.Generic；
命名空间控制台应用程序2
{
使用StrObjDict=字典；
公共密封类CustomComparer:IComparer
{
公共整数比较（StrObjDict lhs、StrObjDict rhs）
{
双x=（双）lhs[“数字”]；
双y=（双）rhs[“数字”]；
返回x.CompareTo（y）；
}
}
内部课程计划
{
私有静态void Main（）
{
var dict1=新的STROBDICT
{
{“name”，“name1”}，
{“数字”，0.0158}
};
var dict2=新的STROBDICT
{
{“name”，“name2”}，
{“数字”，0.0038}
};
var dict3=新的STROBDICT
{
{“name”，“name3”}，
{“数字”，0.0148}
};
var list=新列表{dict1，dict2，dict3}；
排序（new CustomComparer（））；
foreach（列表中的var元素）
{
WriteLine（“Name={0}，Number={1}”、元素[“Name”]、元素[“Number”]）；
}
}
}
}

最后，请注意，只有当您希望在字典中动态存储其他内容时，这种方法才有意义。如果您只在每个字典中存储“name”和“number”，那么您应该创建一个特定的类来存储该数据，而不是使用字典
这种方法看起来可能是这样的——注意它是多么简单（而且也是类型安全的！）：
使用系统；
使用System.Collections.Generic；
命名空间控制台应用程序2
{
公共密封类条目
{
公共只读字符串名称；
公共只读双倍数字；
公共条目（字符串名称，双倍数字）
{
名称=名称；
数字=数字；
}
}
内部课程计划
{
私有静态void Main（）
{
变量列表=新列表
{
新条目（“名称1”，0.0158），
新条目（“名称2”，0.0038），
新条目（“名称3”，0.0148）
};
list.Sort（（左、右）=>lhs.Number.CompareTo（右编号））；
//或者，如果不需要就地排序，则
//要保留原始未排序列表，可以创建
//使用Linq的单独排序列表，如下所示：
//
//var sortedList=list.OrderBy（x=>x.Number.ToList（）；
foreach（列表中的var元素）
{
WriteLine（“Name={0}，Number={1}”，element.Name，element.Number）；
}
}
}
}
正如马修·沃森（Matthew Watson）所说，字典不是连续的集合，所以我建议使用列表

我建议您使用List
，因为您似乎使用int
键作为查找适当的词典和List


对于您的列表排序，这可以解决以下问题：
using System;
using System.Collections.Generic;

namespace ConsoleApplication2
{
    using StrObjDict = Dictionary<string, object>;

    public sealed class CustomComparer: IComparer<StrObjDict>
    {
        public int Compare(StrObjDict lhs, StrObjDict rhs)
        {
            double x = (double)lhs["number"];
            double y = (double)rhs["number"];

            return x.CompareTo(y);
        }
    }

    internal class Program
    {
        private static void Main()
        {
            var dict1 = new StrObjDict
            {
                {"name",   "name1"},
                {"number", 0.0158}
            };

            var dict2 = new StrObjDict
            {
                {"name",   "name2"},
                {"number", 0.0038}
            };

            var dict3 = new StrObjDict
            {
                {"name",   "name3"},
                {"number", 0.0148}
            };

            var list = new List<StrObjDict> {dict1, dict2, dict3};

            list.Sort(new CustomComparer());

            foreach (var element in list)
            {
                Console.WriteLine("Name = {0}, Number = {1}", element["name"], element["number"]);
            }
        }
    }
}

using System;
using System.Collections.Generic;

namespace ConsoleApplication2
{
    public sealed class Entry
    {
        public readonly string Name;
        public readonly double Number;

        public Entry(string name, double number)
        {
            Name   = name;
            Number = number;
        }
    }

    internal class Program
    {
        private static void Main()
        {
            var list = new List<Entry>
            {
                new Entry("name1", 0.0158),
                new Entry("name2", 0.0038),
                new Entry("name3", 0.0148)
            };

            list.Sort((lhs, rhs) => lhs.Number.CompareTo(rhs.Number));

            // Alternatively if you don't want an in-place sort and you
            // want to keep the original unsorted list, you can create
            // a separate sorted list using Linq like so:
            //
            // var sortedList = list.OrderBy(x => x.Number).ToList();

            foreach (var element in list)
            {
                Console.WriteLine("Name = {0}, Number = {1}", element.Name, element.Number);
            }
        }
    }
}

        List<Dictionary<string, string>> myDict = new List<Dictionary<string, string>>();
        myDict.Add(new Dictionary<string, string>());
        myDict.Add(new Dictionary<string, string>());
        myDict.Add(new Dictionary<string, string>());
        myDict[0].Add("name", "name1");
        myDict[0].Add("number", "0.0158");
        myDict[1].Add("name", "name2");
        myDict[1].Add("number", "0.0038");
        myDict[2].Add("name", "name3");
        myDict[2].Add("number", "0.0148");

        var result = myDict.SelectMany(x => x.Where(d => d.Key == "number")).OrderBy(x => x.Value);

class Foo
{
    public string Name { get; set; }
    public double Number { get; set; }
}

List<Foo> myDict = new List<Foo>();
myDict.Add(new Foo() { Name = "name1", Number = 0.0158 });
myDict.Add(new Foo() { Name = "name2", Number = 0.0038 });
myDict.Add(new Foo() { Name = "name3", Number = 0.0148 });
var result = myDict.OrderBy(x => x.Number);

myDict = myDict.Values
    .OrderBy(val => double.Parse(val["number"]))
    .Select((val, idx) => new{Key = idx, Value = val})
    .ToDictionary(pair => pair.Key, pair => pair.Value);

myDict = myDict.Values
    .OrderBy(val => double.Parse(val["number"]))
    .Zip(myDict.Keys.OrderBy(key => key), (val, key) => new{Key = key, Value = val})
    .ToDictionary(pair => pair.Key, pair => pair.Value);