C# 从对象列表C中的列表中获取值#

我有一个

类对象（obj1）

的

列表

，该类包含另一个不同

类对象（obj2）

的

列表。下面是我的代码：

public List<Class1> Obj1{ get; set; }

 public class Class1
    {
        [DataMember]
        public int Class1Id { get; set; }
        [DataMember]
        public string Class1Desc { get; set; }
        [DataMember]
        public List<Class2> obj2{ get; set; }
    }

public class Class2
    {
        [DataMember]
        public int Class2Id { get; set; }
        [DataMember]
        public string Class2Desc { get; set; }
    }

public List Obj1{get；set；}
公共班级1
{
[数据成员]
公共int Class1Id{get；set；}
[数据成员]
公共字符串classdesc{get；set；}
[数据成员]
公共列表obj2{get；set；}
}
公共课2
{
[数据成员]
public int Class2Id{get；set；}
[数据成员]
公共字符串Class2Desc{get；set；}
}

现在，我需要填充变量，确保不会得到重复的值（即
classid
和
Class2Id
的组合应该是唯一的）

我不想使用循环。如何实现这一点？
使用
IEquatable
然后使用
Distinct（）
：

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用系统数据；
命名空间控制台应用程序52
{
班级计划
{
静态void Main（字符串[]参数）
{
列表Obj1=新列表{
new Class1（）{classdesc=“A”，Class1Id=1，obj2=new List（）{new Class2（）{Class2Id=100，Class2Desc=“M”}}，
new Class1（）{classdesc=“B”，Class1Id=1，obj2=new List（）{new Class2（）{Class2Id=100，Class2Desc=“M”}}，
new Class1（）{classdesc=“A”，Class1Id=1，obj2=new List（）{new Class2（）{Class2Id=100，Class2Desc=“M”}}，
new Class1（）{classdesc=“A”，classaid=1，obj2=new List（）{new Class2（）{Class2Id=200，Class2Desc=“M”}}
};
List distinctClass1=Obj1.Distinct（）.ToList（）；
}
}
公共类1：可满足
{
公共int Class1Id{get；set；}
公共字符串classdesc{get；set；}
公共列表obj2{get；set；}
公共布尔等于（类别1其他）
{
if（other==null）返回false；
if（（this.classaid==other.classaid）&&（this.classdesc==other.classdesc）&&（this.obj2.OrderBy（x=>x）.SequenceEqual（other.obj2.OrderBy（x=>x）））
{
返回true；
}
其他的
{
返回false；
}
}
公共覆盖int GetHashCode（）
{
return（this.classaid.ToString（）+“^”+this.classdesc+string.Join（“^”，obj2.Select（x=>x.GetHashCodeStr（）））.GetHashCode（）；
}
}
公共类2：IEquatable，IComparer
{
public int Class2Id{get；set；}
公共字符串Class2Desc{get；set；}
公共布尔等于（类2其他）
{
if（other==null）返回false；
if（（this.Class2Id==other.Class2Id）&&（this.Class2Desc==other.Class2Desc））
{
返回true；
}
其他的
{
返回false；
}
}
公共整数比较（Class2X，Class2Y）
{
int结果=0；
结果=x.Class2Id.与（y.Class2Id）相比；
如果（结果==0）
{
结果=x.Class2Desc.与（y.Class2Desc）相比；
}
返回结果；
}
公共覆盖int GetHashCode（）
{
返回（this.Class2Id.ToString（）+“^”+this.Class2Desc）.GetHashCode（）；
}
公共字符串GetHashCodeStr（）
{
返回this.Class2Id.ToString（）+“^”+this.Class2Desc；
}
}
}
您可以使用您在Class1中使用的某种方法单独设置它们。您可以使用
哈希集
？“现在，我需要填充变量”-哪些变量？班上的那个？如果是，您的数据来源是什么？或者您正在从Obj1列表中填充其他变量，在这种情况下，您想要填充哪些变量以及使用哪些数据？这里有一个线性关系：var result=Obj1.SelectMany（x=>x.obj2.Select（y=>new{x，y}））.GroupBy（t=>new{t.x.classid，t.y.Class2Id}.Select（x=>x.First（））.ToList（）；你能举个例子吗？你认为这个标题合适吗？你认为正则表达式是相关的吗？我认为你可能需要实现的不仅仅是
IEquatable
，才能让
Distinct
起作用-我相信
GetHashCode
也需要
Distinct（）
将创建一个
EqualityComparer.Default
，它依赖于
GetHashCode
。至少你的代码对我不起作用，我想这就是原因所在。这如何确保“我不会得到重复的值（即ClassID和Class2Id的组合应该是唯一的）”？我猜一个
Class1
实例是另一个
Class1
实例的副本，如果两者都有相交的
new[]{classid}.Union（obj2.Select（x=>x.Class2Id））
整数。但可能所有整数都必须相同，而不仅仅是一个。我很惊讶没有使用GetHashCode（）编译的代码没有错误。您真的不需要哈希代码，您可以将其放入哈希返回0中，它就会工作。IEquatable调用GetHashCode首先检查项是否相等，然后在哈希不相等时调用equal方法。如果你只是在做一个比较（而不是<>），为什么要创建一个不需要的散列呢。我相信它使用的是标准列表GetHashCode作为默认值。通常使用GetHashCode（）覆盖。@Tim Schmelter:IEquatable处理重复项。我的代码假设类1和类2中的所有对象都必须相同。类是列表对象，因此标准的list Equal用作比较的基类。@jdweng:是代码的精简版本（删除类2）。它似乎没有检测到添加到列表中的重复对象（应该有10个DI）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;

namespace ConsoleApplication52
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Class1> Obj1 = new List<Class1> {
                new Class1() { Class1Desc = "A", Class1Id = 1, obj2 = new List<Class2>() { new Class2() { Class2Id = 100, Class2Desc= "M"}}},
                new Class1() { Class1Desc = "B", Class1Id = 1, obj2 = new List<Class2>() { new Class2() { Class2Id = 100, Class2Desc= "M"}}},
                new Class1() { Class1Desc = "A", Class1Id = 1, obj2 = new List<Class2>() { new Class2() { Class2Id = 100, Class2Desc= "M"}}},
                new Class1() { Class1Desc = "A", Class1Id = 1, obj2 = new List<Class2>() { new Class2() { Class2Id = 200, Class2Desc= "M"}}}
            };

            List<Class1> distinctClass1 = Obj1.Distinct().ToList();
        }
    }
    public class Class1 : IEquatable<Class1>
    {
        public int Class1Id { get; set; }
        public string Class1Desc { get; set; }
        public List<Class2> obj2 { get; set; }

        public Boolean Equals(Class1 other)
        {

            if (other == null) return false;
            if ((this.Class1Id == other.Class1Id) && (this.Class1Desc == other.Class1Desc) && (this.obj2.OrderBy(x => x).SequenceEqual(other.obj2.OrderBy(x => x))))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        public override int GetHashCode()
        {
            return (this.Class1Id.ToString() + "^" + this.Class1Desc + string.Join("^", obj2.Select(x => x.GetHashCodeStr()))).GetHashCode();
        }

    }

    public class Class2 : IEquatable<Class2> , IComparer<Class2>
    {
        public int Class2Id { get; set; }
        public string Class2Desc { get; set; }

        public Boolean Equals(Class2 other)
        {
            if(other == null) return false;
            if ((this.Class2Id == other.Class2Id) && (this.Class2Desc == other.Class2Desc))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        public int Compare(Class2 x, Class2 y)
        {
            int results = 0;
            results = x.Class2Id.CompareTo(y.Class2Id);
            if (results == 0)
            {
                results = x.Class2Desc.CompareTo(y.Class2Desc);
            }
            return results;
        }
        public override int GetHashCode()
        {
            return (this.Class2Id.ToString() + "^" + this.Class2Desc).GetHashCode();
        }
        public string GetHashCodeStr()
        {
            return this.Class2Id.ToString() + "^" + this.Class2Desc;
        }

    }
}