C# 重组对象

我想拿一个这样的物体：

SortedList<string, SortedList<int, SortedList<DateTime, double>>> Data

SortedList<DateTime, SortedList<string, double>>

SortedList数据

对于给定的“int”值（第一个嵌套排序列表的键），按如下方式重新构造它：

SortedList<string, SortedList<int, SortedList<DateTime, double>>> Data

SortedList<DateTime, SortedList<string, double>>

SortedList

或者，更好的办法是：

SortedList<DateTime, double[]>

SortedList

其中，每个“double[]”的元素数量与SortedList中的键值对数量相同

---

我猜Linq是个不错的选择，但我想不出来。谢谢你的建议。

第二种情况非常好：

var dateGroups = Data.SelectMany(x => x.Value)
                     .SelectMany(x => x.Value)
                     .GroupBy(x => x.Key)
                     .ToSortedList(g => g.Key, 
                                   g => g.Select(x => x.Value).ToArray());

第一个案例似乎是错误的，我怀疑应该是：

SortedList<DateTime, SortedList<string, double[]>>

其中

ToSortedList

是以下扩展名：

public static class Exts
{
    public static SortedList<TK, TV> ToSortedList<TEl, TK, TV>(
        this IEnumerable<TEl> elements,
        Func<TEl, TK> keySelector, 
        Func<TEl, TV> valueSelector)
    {
        if(elements == null || keySelector == null || valueSelector == null)
            throw new ArgumentNullException("An argument of ToSortedList is null");
        var dict = new SortedList<TK, TV>();
        foreach (var el in elements)
            dict.Add(keySelector(el), valueSelector(el));
        return dict;
    }
}

公共静态类Exts
{
公共静态分类列表到分类列表(
这是数不清的元素，
Func键选择器，
Func值选择器）
{
if（elements==null | | keySelector==null | | valueSelector==null）
抛出新ArgumentNullException（“ToSortedList的参数为null”）；
var dict=新的分类列表（）；
foreach（元素中的变量）
dict.Add（键选择器（el）、值选择器（el））；
返回命令；
}
}

DigeMail比我更容易理解，但下面是查询理解语法中的第二种情况：

int desiredInt = //whatever...

var query = from pair in Data
        from pair2 in pair.Value
        where pair2.Key == desiredInt
        from pair3 in pair2.Value
        group pair3.Value by pair3.Key into grp
        select new { grp.Key, Value = grp.ToArray() };

var result = new SortedList<DateTime, double[]>(query.ToDictionary(a => a.Key, a => a.Value));

int desiredit=//随便什么。。。
var query=来自数据中的对
来自成对的pair2。值
其中pair2.Key==desiredInt
从pair2.Value中的pair3开始
按pair3.Key将pair3.Value分组到grp中
选择新的{grp.Key，Value=grp.ToArray（）}；
var result=newsortedList（query.ToDictionary（a=>a.Key，a=>a.Value））；

intgivenkey=。。。；
var variant1=新分类列表(
Data.Select（pair=>new{str=pair.Key，dateValues=pair.Value[givenKey]}）
.Where（pair=>pair.dateValues！=null）
.SelectMany（pair=>pair.dateValues.Select（dateValue=>new{pair.str，date=dateValue.Key，value=dateValue.value}））
.GroupBy（pair=>pair.date）
.ToDictionary（group=>group.Key，group=>newsortedList（group.ToDictionary（triple=>triple.str，triple=>triple.value）））
);
var variant2=新分类列表(
Data.Select（pair=>new{str=pair.Key，dateValues=pair.Value[givenKey]}）
.Where（pair=>pair.dateValues！=null）
.SelectMany（pair=>pair.dateValues.Select（dateValue=>new{pair.str，date=dateValue.Key，value=dateValue.value}））
.GroupBy（pair=>pair.date）
.ToDictionary（group=>group.Key，group=>group.Select（triple=>triple.value）.ToArray（））
);

如果使用DateTime的完整分辨率，则无法进行转换，除非系统以某种方式将插入的DateTime值正则化。即使是非常快速的插入也可能发生在不同的刻度上。如果将其正则化，则可以获得如下值：

Dictionary<DateTime, double[]> results = (from d1 in Data
                                          from d2 in d1.Value
                                          where d2.Key == 1
                                          from d3 in d2.Value
                                          group d3 by d3.Key into d3Group
                                          select new {Key = d3Group.Key, Value = (from d4 in d3Group
                                                                                  select d4.Value).ToArray()
                                                      }).ToDictionary(element => element.Key, element => element.Value);

SortedList<DateTime, double[]> newSortedList = new SortedList<DateTime, double[]>(results);

字典结果=（来自数据中的d1
从d1中的d2开始。值
其中d2.Key==1
从d2中的d3开始。值
将d3按d3分组。键入d3组
选择新的{Key=d3Group.Key，Value=（来自d3Group中的d4
选择d4.Value）.ToArray（）
}).ToDictionary（元素=>element.Key，元素=>element.Value）；
SortedList newSortedList=新的SortedList（结果）；
< /代码>  PHOOG的答案是好的，但是也许你应该考虑<代码> ILookup <代码>而不是<代码> SoRealdList…< /P>
ILookup<DateTime, double> result =
(
  from pair1 in Data
  from pair2 in pair1.Value
  where pair2.Key == givenInt
  from pair3 in pair2.Value
  from theDouble in pair3.Value
  select new {theDateTime = pair3.Key, theDouble = theDouble }
)
.ToLookup(x => x.theDateTime, x => x.theDouble);

ILookup结果=
(
来自数据中的pair1
来自pair1中的pair2。值
其中pair2.Key==givenInt
从pair2.Value中的pair3开始
从配对中的双3.值
选择new{theDateTime=pair3.Key，theDouble=theDouble}
)
.ToLookup（x=>x.日期，x=>x.双倍）；
请不要用C#或LINQ作为开头，这是标记的用途。顶级列表是否可以有多个键值对，其中列表包含与键相同的
int
？如果使用DateTime的完全分辨率，则无法进行转换，除非系统以某种方式将插入的DateTime值正则化。即使是非常快速的插入也可能发生在不同的刻度上。。。。每个“double[]”包含的元素与哪个SortedList中的键值对一样多？@JamieSee为什么认为日期时间与系统时钟有关？