我确定有一种很好的方法可以做到这一点(我猜测其中一种扩展方法？),但我很难在Google上找到它.

基本上我有一个自定义类列表;我想从中选择一些项目到一个新的List中,其中一个属性等于另一个List中的任何值.

这是我正在尝试做的一个(简化)快速示例：

public class Job
    {
        public int Number;
        public string ClientCompanyName;            
    }

List<Job> lstJobs = new List<Job>();
List<Job> lstCompare = new List<Job>();

通常我会这样做：

List<Job> lstFiltered = new List<Job>();
foreach(Job jobThis in lstCompare)
{
    foreach(jobComp in lstCompare)
    {
        if(jobThis.Number = jobComp.Number)
        {
            lstFiltered.Add(jobThis);
        }
    }
}

是否有一种扩展方法可以将最后一位加入(理想情况下)单行？

干杯

var lstFiltered = lstJobs
        .Where(job => lstCompare.Any(item => item.Number == job.Number))
        .ToList();

如果lstCompare中的项目数量很少,则上述解决方案很有效.对于更大的比较列表,您可能希望使用一些基于散列的集合.

var compareSet = new HashSet<int>(lstCompare.Select(item => item.Number));
var lstFiltered = lstJobs
        .Where(job => compareSet.Contains(job.Number))
        .ToList();

如果比较条件更复杂或者在几个地方需要它,则应创建一个实现IEqualityComparer< T>的比较器类.然后你可以像其他人已经建议的那样使用Intersect()方法.但是,它在功能上与上述解决方案不同.当我的解决方案返回所有匹配元素时,它只返回不同的元素在某些应用中,这可能是一个显着的差异.

我的第二个例子可以很容易地改为使用IEqualityComparer< T>如有必要. HashSet< T>将比较器作为第二个参数.

我有以下列表：

public class Products
{
 public string SKU;
 public int WarehouseID;
}

List<Products> products = new List<Products>();

在填写列表之后,我得到以下数据：

ProductCode|WarehouseID
SKU001|2
SKU001|3
SKU002|3
SKU003|3
SKU004|1
SKU004|5

我有多个SKU的项目可以从多个仓库位置提供,因为它有库存.在SKU001的情况下,仓库ID 2的库存比仓库ID 3多.

我需要从最少数量的仓库位置选择项目.我想要结束的就是这样

SKU001|3
SKU002|3
SKU003|3
SKU004|1

这将产品选择限制为只有2个位置,如SKU001,SKU002& SKU003都可以从仓库ID 3获得.理想地从库存最多但限制位置的位置选择更重要.

我正在使用Linq尝试实现这一点,同时尝试循环每个List项目,但是正在努力,因为Linq对我来说不是一个强项.我试图首先得到重复仓库ID使用的最高数量

products.GroupBy(i => i).OrderByDescending(grp => grp.Count()).Select(grp => grp.Key).FirstOrDefault();

但是其余的项目却迷失了.有什么想法,我可以如何解决这个问题？

您可以在多个语句中执行此操作,首先在每个仓库中获取WarehouseID以及不同的产品,其数量如下所示：

var query = products.GroupBy(r => r.WarehouseID)
                    .Select(grp => new
                    {

                        WarehouseID = grp.Key,distinctProducts = grp.Select(r => r.SKU).distinct(),distinctCount = grp.Select(r => r.SKU).distinct().Count(),});

稍后创建一个结果列表,如：

List<Products> result = new List<Products>();

foreach (var item in query.OrderByDescending(r => r.distinctCount)) //warehouse with most products
{
    if (!result.Any(r => item.distinctProducts.Any(t => t == r.SKU)))
    {
        result.AddRange(item.distinctProducts.Select(r => new Products { SKU = r,WarehouseID = item.WarehouseID }));
    }
}

输出：

foreach (var item in result)
{
    Console.WriteLine("{0} | {1}",item.SKU,item.WarehouseID);
}

输出：

SKU001 | 3
SKU002 | 3
SKU003 | 3
SKU004 | 1

我有以下场景：
int：List< int>的列表idsOnly = new List< int>();
和另一个对象列表,它应该带来所有项目,它们的ID与列表idsOnly匹配

var myList = db.Items.Where(item => idsOnly.Contains(item.ID.Value))
                     .Select(a => new { a.Title })
                     .ToList();

我只需要从myList中获取标题

任何帮助将不胜感激

您的代码有效但它将创建匿名对象列表,而不是字符串类型

如果你只想获得标题,而不是使用(a => new {a.Title},你只需使用a => a.Title：

var myList = db.Items.Where(item => idsOnly.Contains(item.ID.Value))
                     .Select(a => a.Title).ToList();

我有两个清单：

List<objA> list1
List<objB> list2

class objA
{
   string Name;
}

class objB
{
   string Name;
   bool SomeProp;
}

使用C#linq / lambda我想选择所有objA对象,其Name属性等于第二个obj(list1.Name == list2.Name)的name属性,并检查objB的另一个属性(list2.someProp == true ).

我建议使用join：

from a in list1
join b in list2 on a.Name equals b.Name
where b.someProp
select a

Lambda语法：

list1.Join(listb.Where(b => b.someProp),a => a.Name,b => b.Name,(a,b) => a)

注意：因此,您将避免枚举list1中的每个项目的list2集合(使用Any的解决方案)

为了显示两个解决方案之间的区别 – 让我们看看在将linq转换为plain循环后它们的样子.首先是

list1.Where(a => list2.Any(b => b.Name == a.Name && b.someProp))

它相当于

foreach(var a in list1)
{
   foreach(var b in list2)
   {
       if (a.Name == b.Name && b.someProp)
       {
           yield return a;
           break;
       }
   }
}

如您所见 – 它具有嵌套循环,复杂度为O(N * M).通过join,我们为内部序列创建了Lookup：

Lookup<string,objB> lookup = list2.Where(b => b.someProp).ToLookup(b => b.Name);

foreach(var a in list1)
{
    Grouping<string,objB> g = lookup.GetGrouping(a.Name);
    if (g == null)
       continue;

    foreach(var b in g)
       yield return a;
}

这里的区别是在查找中搜索 – 这是O(1)操作.总复杂度为O(M N)