Question

我有一个班级：

public class DataMember {
    public string ID{ get; set; }
    public List<string> Versions { get; set; }
}

另一堂课：

public class MasterDataMember {
    public string ID { get; set; }
    public List<string> FoundVersions { get; set; }
}

我将两组数据存储在Cache中：

List<DataMember> datamembers
List<MasterDataMember> masterdatamembers

最初构建时，MasterDataMember是部分＆＃34;版本＆＃34;的列表。需要确认这些版本，并在DataMember列表中找到。

如何使用datamembers中的确认版本更新masterdatamembers？（此代码块未经测试，但它说明了我尝试做的事情）

foreach (MasterDataMember item in masterdatamembers) {
    List<string> confirmedvers = new List<string>();
    foreach(string rawver in item.FoundVersions ){
        foreach(DataMember checkitem in datamembers){
            foreach (string confirmedver in checkitem.Versions) {
                if (rawver.Contains(confirmedver)) {
                    confirmedvers.Add(confirmedver);
                }
            }
        }
    }
    item.FoundVersions = vers;
}

是否有LINQ可以更轻松，更快地完成此任务（我已经尝试了很多想法，迭代）？

速度是关键所在，因为两个列表都可以长达数百到数千个。

提前谢谢！

Answer 1

foreach (MasterDataMember item in masterdatamembers) {
    IEnumerable<string> confirmedvers = item.FoundVersions.Where(rawver => rawver.Any(confirmedver => datamembers.Any(checkitem => checkitem.Versions.Contains(rawver)));
}

HOLY废话兄弟，这让我感到困惑！

虽然很棒的心灵实验！

Answer 2

您的代码在Linq

中看起来像这样

masterDataMembers.ForEach(q=>q.FoundVersions = (from rawver in q.FoundVersions from checkitem in dataMembers from confirmedver in checkitem.Versions where rawver.Contains(confirmedver) select confirmedver).ToList());

Answer 3

如果由于大型列表而导致真正是您的主要关注点，那么您将要使用哈希表构造。使用LINQ很光滑，但不一定能让你更快（或更清晰）。你真正需要的是使用正确的集合类型。

对以下代码的假设：

datamembers缓存不能包含重复的DataMember条目（其中多个条目具有相同的ID）。
masterdatamembers缓存不能包含重复的MasterDataMember条目（其中多个条目具有相同的ID）。
在DataMember和MasterDataMember中，Versions和FoundVersions列表不能包含重复的版本条目。

算法说明

我仍然觉得你的代码块并不能完全反映你的意图。不幸的是，结果，我认为你的答案错了。

这是我遵循的算法，基于尝试解释您的预期结果：

对于每个主数据成员，仅通过保留列表中的版本来更新其FoundVersions集（或列表），该版本也可以在匹配数据成员Versions集中找到（或列表）。如果找不到匹配的数据成员，那么我假设您要清空主数据成员FoundVersions集（或列表），因为没有一个版本可以确认。

<强>实施

请注意，我将List<T>的一些用法替换为Dictionary<K, V>或HashSet<T>，这样可以提高性能。当然，我假设你的名单可能会变得很大，就像你说的那样。否则，性能将与简单列表类似。

你的2个班级，（注意类型的变化）：

public class DataMember
{
    public string ID { get; set; }
    public HashSet<string> Versions { get; set; } // using hashset is faster here.
}

public class MasterDataMember
{
    public string ID { get; set; }
    public HashSet<string> FoundVersions { get; set; } // used HashSet for consistency, but for the purposes of the algorithm, a List can still be used here if you want.
}

您的缓存数据，（注意对词典的更改）：

Dictionary<string, DataMember> datamembers; // using a Dictionary here, where your key is the DataMember's ID, is your fastest option.
List<MasterDataMember> masterdatamembers; // this can stay as a list if you want.

最后，工作在这里完成：

foreach (var masterDataMember in masterdatamembers)
{
    DataMember dataMember;
    if (datamembers.TryGetValue(masterDataMember.ID, out dataMember))
    {
        HashSet<string> newSet = new HashSet<string>();

        foreach (var version in masterDataMember.FoundVersions)
        {
            if (dataMember.Versions.Contains(version))
            {
                newSet.Add(version);
            }
        }

        masterDataMember.FoundVersions = newSet;
    }
    else
    {
        masterDataMember.FoundVersions.Clear();
    }
}

使用类列表中的数据更新类的列表

3 个答案: