C# 查找一个IEnumerable中的项是否也在另一个IEnumerable中

我有两个IEnumerable，分别是Type1和Type2，即

IEnumerable

和

IEnumerable

。Type1和Type2有一个公共字段，称为TypeID。在

IEnumerable

中可能存在多个相同类型ID，我想对照这两个IEnumerable进行检查，如果TypeID内Type2等于TypeID内Type1，我会将这两个对象合并成一个新对象。如果不是，那么新对象只是将

IEnumerable

设置为

null

。这有点让人困惑，所以我加入了一个伪代码来更好地演示我要实现的目标：

namespace test
{
    public class ConfigMetaDataColumns
    {
        public int FieldID { get { return ValueInt("FieldID"); } }
        public string Label { get { return ValueString("Label"); } }
        public string FieldName { get { return ValueString("FieldName"); } }
    }

    public class ConfigDataColumns
    {
        public int FieldID { get { return ValueInt("FieldID"); } }
        public double NumericValue { get { return ValueDouble("NumericValue"); } }
    }

    public class ConfigMetaDataCombinedColumns
    {
        public ConfigMetaDataColumns ConfigMetaData { get; set; }
        public IEnumerable<ConfigDataColumns> ConfigData { get; set; }
    }

    public class GetCombinedData
    {
        // Get ConfigMetaData
        private IEnumerable<ConfigMetaDataColumns> GetConfigMetaData()
        {
            var requester = GetConfigMetaDataMethodHere();
            return requester.Items;
        }

        // Get ConfigMeta
        private IEnumerable<ConfigMetaDataColumns> GetConfigMetaData()
        {
            var requester = GetConfigDataMethodHere();
            return requester.Items;
        }

        // Combine the two here!
        private IEnumerable<ConfigMetaDataCombinedColumns> GetData()
        {
            /*
             * ConfigMetaDataColumns example:
             * FieldID:     1
             * Label:       Label1
             * FieldName:   FieldName1
             * 
             * FieldID:     2
             * Label:       Label2
             * FieldName:   FieldName2
             * 
             * FieldID:     3
             * Label:       Label3
             * FieldName:   FieldName3
             * */

            /*
             * ConfigDataColumns example:
             * FieldID:     1
             * NumericVal:  NumericVal1

             * FieldID:     1
             * NumericVal:  NumericVal2

             * FieldID:     3
             * NumericVal:  NumericVal3
             * */

            /*
             * Cobined data should be:
             * 
             * FieldID:     1
             * Label:       Label1
             * FieldName:   FieldName1
             {* FieldID:    1
             * NumericVal:  NumericVal1
             * FieldID:     1
             * NumericVal:  NumericVal2}
             * 
             * FieldID:     2
             * Label:       Label2
             * FieldName:   FieldName2
             {* NULL *}
             * 
             * FieldID:     3
             * Label:       Label3
             * FieldName:   FieldName3
             {* FieldID:    3
             * NumericVal:  NumericVal3}
             * */
        }
    }
}

名称空间测试
{
公共类ConfigMetaDataColumns
{
public int FieldID{get{return ValueInt（“FieldID”）；}
公共字符串标签{get{return ValueString（“标签”）；}
公共字符串字段名{get{return ValueString（“字段名”）；}
}
公共类ConfigDataColumns
{
public int FieldID{get{return ValueInt（“FieldID”）；}
public double NumericValue{get{return ValueDouble（“NumericValue”）；}
}
公共类ConfigMetaDataCombinedColumns
{
公共ConfigMetaDataColumns ConfigMetaData{get；set；}
公共IEnumerable ConfigData{get；set；}
}
公共类GetCombinedData
{
//获取配置元数据
私有IEnumerable GetConfigMetaData（）
{
var requester=GetConfigMetaDataMethodHere（）；
返回请求者。项目；
}
//获取配置元数据
私有IEnumerable GetConfigMetaData（）
{
var requester=GetConfigDataMethodHere（）；
返回请求者。项目；
}
//在这里把两者结合起来！
私有IEnumerable GetData（）
{
/*
*ConfigMetaDataColumns示例：
*FieldID:1
*标签：Label1
*字段名：字段名1
* 
*FieldID:2
*标签：Label2
*字段名：字段名2
* 
*FieldID:3
*标签：Label3
*字段名：字段名3
* */
/*
*ConfigDataColumns示例：
*FieldID:1
*NumericVal:NumericVal1
*FieldID:1
*NumericVal:NumericVal2
*FieldID:3
*NumericVal:NumericVal3
* */
/*
*共同定义的数据应为：
* 
*FieldID:1
*标签：Label1
*字段名：字段名1
{*FieldID:1
*NumericVal:NumericVal1
*FieldID:1
*NumericVal:NumericVal2}
* 
*FieldID:2
*标签：Label2
*字段名：字段名2
{*NULL*}
* 
*FieldID:3
*标签：Label3
*字段名：字段名3
{*FieldID:3
*NumericVal:NumericVal3}
* */
}
}
}

---

谢谢。

完全猜测。。。但我认为这就是你想要的：

private IEnumerable<ConfigMetaDataCombinedColumns> ReturnMe()
{
   var query = from meta in GetConfigMetaData().AsQueryable()
            join data in GetConfigDataColumns().AsQueryable()
            on meta.FieldID equals data.FieldID
            select new {
                ConfigMetaDataColumns = meta,
                ConfigDataColumns = data
            };
   return  from item in query
            group item by item.ConfigMetaDataColumns into l 
            select new ConfigMetaDataCombinedColumns()
            {
                ConfigMetaData = l.Key,
                ConfigData = l.Select(x=>x.ConfigDataColumns)

            }        ;
}

private IEnumerable ReturnMe（）
{
var query=来自GetConfigMetaData（）中的meta。AsQueryable（）
连接GetConfigDataColumns（）中的数据。AsQueryable（）中的数据
在meta.FieldID上等于data.FieldID
选择新的{
ConfigMetaDataColumns=meta，
ConfigDataColumns=数据
};
从查询中的项返回
按项分组。将MetadataColumns配置为l
选择新的ConfigMetaDataCombinedColumns（）
{
ConfigMetaData=l.密钥，
ConfigData=l.Select（x=>x.ConfigDataColumns）
}        ;
}

我认为应该这样做。不是最有效的，但您可以改进它，将数据获取函数的结果存储在变量中：

IEnumerable<ConfigMetaDataCombinedColumns> combined =
    GetConfigMetaData()
    .Select(p=> new ConfigMetaDataCombinedColumns() {ConfigMetaData = p
        , ConfigData = GetConfigData().Where(q=>q.FieldID == p.FieldID)  });

IEnumerable组合=
GetConfigMetaData（）
.Select（p=>new ConfigMetaDataCombinedColumns（）{ConfigMetaData=p
，ConfigData=GetConfigData（），其中（q=>q.FieldID==p.FieldID）}）；

我相信，与ResultSelector的连接调用GetData方法，但将对象作为参数传递，将对您有效

//IEnumerable<Type1> List1
//IEnumerable<Type2> List2

var result = List1.Join( List2, a => a.TypeId, b => b.TypeId, (a, b) => GetData(a, b));
//do something with result

//IEnumerable列表1
//IEnumerable列表2
var result=List1.Join（List2，a=>a.TypeId，b=>b.TypeId，（a，b）=>GetData（a，b））；
//做一些有结果的事情

如果我没看错你的问题，你所需要的基本上就是一个左连接

例如：

class Foo
{
    public int SomeId { get; set; }
}

class Bar
{
    public int SomeId { get; set; }
}

class FooWithBars
{
    public Foo Foo { get; set; }
    public IEnumerable<Bar> Bars { get; set; }
}

class-Foo
{
公共int SomeId{get；set；}
}
分类栏
{
公共int SomeId{get；set；}
}
带杆类
{
公共Foo Foo{get；set；}
公共IEnumerable条{get；set；}
}

List foos=new List（）；
列表栏=新列表（）；
Add（newfoo（）{SomeId=1}）；
Add（newfoo（）{SomeId=2}）；
Add（newbar（）{SomeId=1}）；
Add（newbar（）{SomeId=1}）；
//获取所有foo和匹配条
var combled=从foo到foos
将钢筋连接在钢筋中
关于foo.SomeId等于bar.SomeId到g
选择new FootWithBars
{
Foo=Foo，
bar=g.Any（）？g:null
};

---

在本例中，根据您的要求，您会得到一个

IEnumerable

或null。。。你只是想把匹配的元素组合在一起吗？你的第二个IEnumerable在哪里？

List<Foo> foos = new List<Foo>();
List<Bar> bars = new List<Bar>();

foos.Add(new Foo() { SomeId = 1 });
foos.Add(new Foo() { SomeId = 2 });

bars.Add(new Bar() { SomeId = 1 });
bars.Add(new Bar() { SomeId = 1 });

// get all foos and matching bars
var combined = from foo in foos
                join bar in bars
                on foo.SomeId equals bar.SomeId into g
                select new FooWithBars
                {
                    Foo = foo,
                    Bars = g.Any() ? g : null
                };