使用 LINQ 在其他两个项目之间选择项

Question

我正在尝试从字典中的键下方的单个集合创建一个字典集合，字典中的键是类型为"k"的每个文件，每个键的值是类型为"a"的文件。换句话说，我正在尝试建立父子关系，但文件名是唯一的，并不表示"a"和"k"文件类型之间的关系。唯一的关系是文件日期。例如，文件 4 将是类型为"k"的键 b/c，其值将是文件 3 和 2，因为它们的文件日期大于文件 3 的日期。文件 1 不应作为文件 4 的子项包含在内，因为它的类型为"K"，即使它的日期大于文件 3。

要使用的单个集合：

IEnumerable<IFile>
file name   file type   file date
file1       k           2013-01-01
file2       a           2012-03-30
file3       a           2012-02-27
file4       k           2012-02-23
file5       a           2011-03-31
file6       k           2011-02-24
file7       a           2010-08-24
file8       a           2010-03-31
file9       k           2010-02-26

期望输出：

Dictionary<IFile, IEnumerable<IFile>>
key     value
file1   none b/c no files of type "a" exist with a date greater than file1
file4   file3, file2
file6   file5
file9   file8, file7

Answer 1

你可以做这样的事情：

var result = data.Where(x => x.Type == 'k')
                 .ToDictionary(x => x.Name,
                               x => data.Where(a => a.Type == 'a' &&
                                               a.Date >= x.Date)
                                        .Select(a => a.Name)
                                        .ToList());

不过，这并不能完全得到你想要的 - 因为 2010-02-26 的条目将包括所有未来的条目。所以这不仅仅是这种关系的一个案例：

例如，文件 4 将是类型为"k"的键 b/c，其值将是文件 3 和 2，因为它们的文件日期大于文件 3 的日期。

听起来实际上是：

例如，文件 4 将是类型为"k"的键 b/c，其值将是文件 3 和 2，因为它们的文件日期大于文件 3 的日期，并且其文件日期小于文件 1 的日期。

那会更棘手。您可能需要类似以下内容：

var orderedKeys = data.Where(x => x.Type == 'k')
                      .OrderBy(x => x.Date)
                      .Concat(null); // You'll see why in a minute...
// Just for convenience. Could make this more efficient, admittedly.
var values = data.Where(x => x.Type == 'a').ToList();
var result = orderedKeys.Zip(orderedKeys.Skip(1),
                             (current, next) => new { current, next })
                        .ToDictionary(pair => pair.current.Name,
     // Sorry for the formatting...
     pair => values.Where(v => v.Date >= pair.current.Date &&
                               pair.next == null || v.Date < pair.next.Date)
                   .Select(v => v.Name)
                   .ToList());

那是如果你想成为真正的 LINQ-y。不过，按日期排序的键和值会更有效：

var ordered = data.OrderBy(x => x.Date);
var result = new Dictionary<string, List<string>>();
var currentList = null;
foreach (var item in ordered)
{
    if (item.Type == 'a' && currentList != null)
    {
        currentList.Add(item.Name);
    }
    else if (item.Type == 'k')
    {
        currentList = new List<string>();
        result[item.Name] = currentList;
    }
}

Answer 2

这是一个相当简单的基于 LINQ 的解决方案（非常简洁，没有我的所有评论）：

// first, get the key files in order by date
var orderedKeys = files.Where(f => f.Type == 'k')
   .OrderBy(f => f.Date)
    // since I'm going to be enumerating this multiple times, call ToList() so we only
    // do the sort and filter once (if you don't care you could just inline this below)
    .ToList();
// start with all files of type 'a'
var dict = files.Where(f => f.Type == 'a')
    // group the 'a' files by the last key file whose date is <= the date of the 'a'
    // file. Since we've sorted the key files, this should be the correct parent for a
    .GroupBy(f => orderedKeys.Where(key => key.Type == 'k').Last(key => key.Date <= f.Date))
    // finally, convert the groups to a Dictionary
    .ToDictionary(g => g.Key, g => g);

请注意，这有点低效，因为它循环遍历每个"a"文件可枚举的 orderedKeys（如果文件列表不是太大，简洁可能是值得的）。若要避免这种情况，可以使用非 LINQ 迭代解决方案，从对整个文件列表进行排序开始。

Answer 3

您可以使用

此答案中的Split扩展方法来获取每个键的项目。 然后，您可以将键与项目Zip，并将序列转换为Dictionary。

var orderedFiles = files.OrderBy(f => f.Date).ToArray();
var keys = orderedFiles.Where(f => f.Type == 'k');
// Call Skip(1) to skip the items that are before any keys.
var itemGroups = orderedFiles.Split(f => f.Type == 'k').Skip(1);
var result = keys.Zip(itemGroups, (key, items) => new { key, items })
                 .ToDictionary(x => x.key, x => x.items);

这是扩展方法：

public static IEnumerable<IEnumerable<TSource>> Split<TSource>(
    this IEnumerable<TSource> source,
    Func<TSource, bool> predicate)
{
    List<TSource> group = new List<TSource>();
    foreach (TSource item in source)
    {
        if (predicate(item))
        {
            yield return group.AsEnumerable();
            group = new List<TSource>();
        }
        else
        {
            group.Add(item);
        }
    }
    yield return group.AsEnumerable();
}