C# 从列表中查找元素以匹配另一个列表中的每个元素

Question

我的想法是我有一个对象GrossPanel，它有一个属性GrossPanel.PanelList，其中包含Panelobjects 的列表；List<Panel>

每个Panelobject 都具有double Panel.Prod_Width 类型的属性

我想做的是将input中的每个Panel.Prod_Width与template.PanelList中的每个Panel.Prod_Width匹配

找到匹配项后，来自inputlist 的Panel 被放入一个新的GrossPanelobject 并从input 中删除。如果找到完整的匹配集，则将生成的 GrossPanel 添加到 _Returnlist 并重复每个操作，直到用完 input 列表。

例子：

假设input包含9个元素（Panel0-Panel8）和template包含2个元素（temp0-temp1）

• Panel0-Panel3 的 Prod_Width = 200
• Panel4-Panel7 的 Prod_Width = 300
• Panel8 的 Prod_Width = 400
• temp0 的 Prod_Width = 200，temp1 的 Prod_Width = 300

这应该创建 4 个GrossPanelobjects，GP0-GP3

• GP0 应包含 Panel0 和 Panel4
• GP1 应包含 Panel1 和 Panel5
• GP2 应该包含 Panel2 和 Panel6
• GP3 应包含 Panel3 和 Panel7

Panel8 无法使用

这是我为此编写的代码。它可以工作，但速度很慢。 有没有办法更有效地做到这一点？我试图做一个foreach 循环并沿途从input 中删除元素，但它不起作用。相反，我使用Index和_index 跳过input 中的“使用”元素

private static List<GrossPanel> Match (List<Panel> input, GrossPanel template)
    {
        List<Panel> _template = template.PanelList.OrderBy(panel => panel.Prod_Width).ToList();
        List<Panel> _input = input.OrderBy(panel => panel.Prod_Width).ToList();
        List<GrossPanel> _Returnlist = new List<GrossPanel>();
        List<int> indexlist = new List<int>(); // list of used indexes
        int Index = 0; //counting the panels you have checked
        while (Index < _input.Count)
        {
            int _index = 0;
            GrossPanel Grosspanel = new GrossPanel();
            for (int templateindex = 0; templateindex < _template.Count(); templateindex++)
            {
                for (int inputindex = _index; inputindex < _input.Count(); inputindex++)
                {
                    if ((!indexlist.Contains(inputindex)) && (_template.ElementAt(templateindex).Prod_Width == _input.ElementAt(inputindex).Prod_Width))
                    {
                        indexlist.Add(inputindex);
                        Grosspanel.AddNetPanel(input.ElementAt(inputindex));
                        _index = indexlist.Last(); // 
                        Index++;
                        break;
                    }
                }
            }
            if (Grosspanel.NetPanelCount == _template.Count()) _Returnlist.Add(Grosspanel);
            else if (Grosspanel.NetPanelCount != _template.Count()) Index = _input.Count;
        }
        return _Returnlist;
    }

好的……

我尝试使用IEnuberable 和yield return 来加快速度。我现在的问题是，当我在 input 中找到匹配项时，我似乎无法在下一次迭代中将其从 input 中删除。

这里是代码

private static IEnumerable<GrossSteniPanel> Match (IEnumerable<Panel> input, GrossPanel template, List<Panel> usedpanels, int index)
    {
        GrossPanel Grosspanel;
        List<Panel> _usedpanels = new List<Panel>();
        IEnumerable<Panel> _input = input;
        _input = _input.Except(usedpanels);
        if (index < 0 | (_input.Count() == 0)) yield return Grosspanel = new GrossPanel();
        else
        { 
            foreach (Panel p in _input)
            {
                if (p.Prod_Width == template.NetPanelList.ElementAt(index).Prod_Width)
                {
                    _usedpanels.Add(p);
                    _input = _input.Except(_usedpanels);
                    foreach (GrossPanel panel in Match (_input, template, usedpanels, index - 1))
                    {
                        Grosspanel = panel;
                        Grosspanel.AddNetPanel(p);
                        yield return Grosspanel;
                    }
                }
            }
        }
    } 

我错过了什么？？

Answer 1

我的建议：

• 尽量让您的代码更易于阅读和理解（在 99% 的情况下，这比性能更重要）。
• 命名变量时使用一种约定。我在“Match”方法的前 5 行中发现了 4 种不同的命名约定。
• 在局部变量名前使用下划线不好。
• 尝试为“Match”方法编写测试。

重构示例（名称“Match”更改为“BuildGrossPanelList”）：

static IList<GrossPanel> BuildGrossPanelList(List<Panel> input, GrossPanel template)
{
    var templatePanels = template.PanelList
        .OrderBy(panel => panel.Width);

    var inputPanels = input
        .OrderBy(panel => panel.Width)
        .ThenBy(panel => panel.Id);        
    // If `input` can have elements with the same `panel.Width` 
    // and you want to always retun the same result then the sorting has to be extend.

    var templatesWithMatchingPanels = templatePanels
        .ToDictionary(
            tp => tp,
            tp => inputPanels.Where(p => p.Width == tp.Width).ToList());

    return GetGrossPanels(templatesWithMatchingPanels);
}

static IList<GrossPanel> GetGrossPanels(Dictionary<Panel, List<Panel>> templatesWithMatchingPanels)
{
    var result = new List<GrossPanel>();
    while(AnyNotUsedPanelExistsForEveryTemplate(templatesWithMatchingPanels))
    {
        result.Add(CreateNewGrossPanel(templatesWithMatchingPanels));
    }
    return result;
}

static bool AnyNotUsedPanelExistsForEveryTemplate(Dictionary<Panel, List<Panel>> templatesWithMatchingPanels)
{
    return templatesWithMatchingPanels.All(entry => entry.Value.Any());
}

static GrossPanel CreateNewGrossPanel(Dictionary<Panel, List<Panel>> templatesWithMatchingPanels)
{
    var result = new GrossPanel();
    foreach(var templatePanelEntry in templatesWithMatchingPanels)
    {
        var firstMatchingPanel = GetAndRemoveFirst(templatePanelEntry.Value);
        result.AddNetPanel(firstMatchingPanel);
    }
    return result;
}

static Panel GetAndRemoveFirst(IList<Panel> panels)
{
    var result = panels.First();
    panels.RemoveAt(0);
    return result;
}

如果“Match”方法是一个大类的一部分，至少把上面的代码放在一个嵌套类中。考虑在单独的文件中创建一个新类。这个新类中的方法不必是静态的。