C# 过滤具有不同值和列表大小的列表的可靠方法

在C语言中，从不同大小和不同值的多个列表中筛选数据的正确而可靠的方法是什么

我有5个列表（示例）：

一,。Wire1{“HC:1”、“OGB:2”、“KEL:1”、“组织：8”、“HAS:10”}

Wire2{“HC:1”、“OSB:1”、“KEL:1”、“组织：1”、“HPS:5”、“组织：12”、“HAS:25”}

Wire3{“HC:5”、“ORB:5”、“KEL:1”、“组织：2”、“HPS:4”、“OLG:1”}

Wire4{“HC:4”、“OGB:2”、“KEL:1”、“组织：1”、“HFS:5”}

Wire5{“HC:1”、“OGB:5”、“KEL:1”、“组织：2”、“HAS:5”、“CCC:1”、“ORC:10”、“HAS:5”}

我需要检查导线是否具有相同的连接（这些是上面示例中的列表元素）并返回它们

public class HarnessAndHousings  //List<HarnessAndHousings> Lists...
    {
        public int id { get; set; }
        public string issue { get; set; }
        public string Harness { get; set; }
        public List<string> Housings { get; set; } = new List<string>();
    }

public class Errors  // -> List<Errors> Output; 
    {
        public string harness { get; set; }
        public string harness2 { get; set; }
        public string housing { get; set; }
    }

//What i did is horrible but how to do that in another way correct way?

  public static void CheckErrors(List<HarnessAndHousings> harness)
        {
            foreach(HarnessAndHousings h in HarnessAndHousings)
            {
                foreach(string s in h.Housings)
                {
                    foreach(HarnessAndHousings h2 in HarnessAndHousings)
                    {
                        List<string> matches = h2.Housings.Where(x => h2.Housings.Contains(s)).ToList();

                        foreach(string m in matches)
                        {
                            Errors.Add(new Errors { harness = h.Harness, harness2 = h2.Harness, housing = m });
                        }

                        Console.WriteLine(Errors.Count);
                    }
                }
            }
        }

public class harnessandshouses//列表。。。
{
公共int id{get；set；}
公共字符串问题{get；set；}
公共字符串线束{get；set；}
公共列表{get；set；}=new List（）；
}
公共类错误//>列表输出；
{
公共字符串线束{get；set；}
公共字符串控制2{get；set；}
公共字符串包含{get；set；}
}
//我所做的很可怕，但如何以另一种正确的方式做到这一点呢？
公共静态无效检查错误（列表线束）
{
foreach（线束和壳体中的线束和壳体h）
{
foreach（h.外壳中的串s）
{
foreach（线束和壳体中的线束和壳体h2）
{
List matches=h2.houses.Where（x=>h2.houses.Contains））.ToList（）；
foreach（匹配中的字符串m）
{
添加（新错误{线束=h.线束，线束2=h2.线束，外壳=m}）；
}
Console.WriteLine（Errors.Count）；
}
}
}
}

您的代码有一些问题或不完整。但是，如果您要查找的只是“具有相同连接的导线”，则可以使用IEnumerable获取匹配项

//Wire1{"HC:1", "OGB:2", "KEL:1", "ORG:8", "HAS:10" }
var wire1 = new List<string>();
//Wire2{"HC:1", "OSB:1", "KEL:1", "ORG:1", "HPS:5", "ORG:12", "HAS:25"}
var wire2 = new List<string>();

//matching: {"HC:1", "KEL:1" }
var matchingWires = wire1.Intersect(wire2);

使用任一结果列表，您都可以通过以下方式快速获取错误列表：

var errors = matchingWires.Select(x => new Errors { //fill your object accordingly 
});                   

请注意，以上列表仅用于演示目的，未正确实例化

HTH

不公平的解决方案：

    static void Main(string[] args) {
        var wire1 = new List<string>() { "HC:1", "OGB:2", "KEL:1", "ORG:8", "HAS:10" };
        var wire2 = new List<string>() { "HC:1", "OSB:1", "KEL:1", "ORG:1", "HPS:5", "ORG:12", "HAS:25" };
        var wire3 = new List<string>() { "HC:5", "ORB:5", "KEL:1", "ORG:2", "HPS:4", "OLG:1" };
        var wire4 = new List<string>() { "HC:4", "OGB:2", "KEL:1", "ORG:1", "HFS:5" };
        var wire5 = new List<string>() { "HC:1", "OGB:5", "KEL:1", "ORG:2", "HAS:5", "CCC:1", "ORC:10", "HAS:5" };

        var wires = new List<List<string>>() { wire1, wire2, wire3, wire4, wire5 };
        var errors = new List<string>();

        foreach (var wire in wires) {
            var otherWires = wires.ToList();
            otherWires.Remove(wire);

            foreach (var connection in wire) {
                if (otherWires.Any(x => x.Contains(connection))) {
                    errors.Add(connection);
                }
            }
        }

        errors = errors.Distinct().ToList();
        Console.WriteLine(string.Join(", ", errors));
    }

static void Main（字符串[]args）{
var wire1=newlist（）{“HC:1”、“OGB:2”、“KEL:1”、“ORG:8”、“HAS:10”}；
var wire2=新列表（）{“HC:1”、“OSB:1”、“KEL:1”、“组织：1”、“HPS:5”、“组织：12”、“HAS:25”}；
var wire3=newlist（）{“HC:5”、“ORB:5”、“KEL:1”、“ORG:2”、“HPS:4”、“OLG:1”}；
var wire4=newlist（）{“HC:4”、“OGB:2”、“KEL:1”、“ORG:1”、“HFS:5”}；
var wire5=新列表（）{“HC:1”、“OGB:5”、“KEL:1”、“组织：2”、“HAS:5”、“CCC:1”、“ORC:10”、“HAS:5”}；
var wires=new List（）{wire1，wire2，wire3，wire4，wire5}；
var errors=新列表（）；
foreach（导线中的var导线）{
var otherWires=wires.ToList（）；
其他电线。移除（电线）；
foreach（导线中的var连接）{
if（otherWires.Any（x=>x.Contains（连接）））{
错误。添加（连接）；
}
}
}
errors=errors.Distinct（）.ToList（）；
Console.WriteLine（string.Join（“，”，errors））；
}

我发现前面显示的示例和后面的代码没有共同之处。请在你的问题中加入一个代码，该代码根据需要构建列表，以证明你看到的问题。最后一句话说明了你需要做什么，但不清楚。你所说的“如果电线有相同的连接”是什么意思？这可能意味着很多事情。你发布的代码说它正在检查错误，但我们不知道这意味着什么。它正在添加到

列表中。没有电线。我无法建立连接（双关语）。是的，它不完整，但我看到的方法是错误的。因为稍后我需要删除相同导线的错误（wire1和wire1），之后需要删除相同的错误（wire1和wire2；wire2和wire1）@QuikBytes不确定我是否了解您需要什么，但可能您正在查找除

之外的

（而不是
Intersect
）？这将产生相反的、不匹配的项目。我将尝试解释这个问题：）我们从客户那里获得文档，文档基本上是电线及其连接。但有时我们会得到错误的文档，电线不能有相同的连接。所以我需要检查这些列表是否有相同的连接。并提供错误的位置。就像我的错误类一样。@QuikBytes可能是最好的，如果你更新你的帖子以包含预期的结果：）无论哪种方式，我肯定你都可以利用内置的可枚举功能来找到你需要的内容。不优雅但看起来不错，但另一种方法是思考errors.Distinct（）的工作原理。。。在你的情况下，它会起作用，但在我的情况下，我认为不会。但是谢谢，我在你的例子中有一些想法。
    static void Main(string[] args) {
        var wire1 = new List<string>() { "HC:1", "OGB:2", "KEL:1", "ORG:8", "HAS:10" };
        var wire2 = new List<string>() { "HC:1", "OSB:1", "KEL:1", "ORG:1", "HPS:5", "ORG:12", "HAS:25" };
        var wire3 = new List<string>() { "HC:5", "ORB:5", "KEL:1", "ORG:2", "HPS:4", "OLG:1" };
        var wire4 = new List<string>() { "HC:4", "OGB:2", "KEL:1", "ORG:1", "HFS:5" };
        var wire5 = new List<string>() { "HC:1", "OGB:5", "KEL:1", "ORG:2", "HAS:5", "CCC:1", "ORC:10", "HAS:5" };

        var wires = new List<List<string>>() { wire1, wire2, wire3, wire4, wire5 };
        var errors = new List<string>();

        foreach (var wire in wires) {
            var otherWires = wires.ToList();
            otherWires.Remove(wire);

            foreach (var connection in wire) {
                if (otherWires.Any(x => x.Contains(connection))) {
                    errors.Add(connection);
                }
            }
        }

        errors = errors.Distinct().ToList();
        Console.WriteLine(string.Join(", ", errors));
    }