Question

我有一个跟随嵌套

的场景

--Orders (List) 
 ----Products (List)
 ------Manufacturers (List) 
       FIELDS 
        -Name
        -Address
        -City

在这种情况下，我需要执行查询，该查询将过滤制造商的城市并返回Orders, Products & only matching city manufacturers

我尝试进行以下查询，但即使城市与制造商不匹配，我也会获得产品的所有列表。

var filteredOrders = from o in Orders
                    from t in o.Products                           
                    where t.Manufacturers.Any(v => v.City == "Hartford")
                    select o;

即使我从select o更改为＆＃39;选择t.Manufacturers＆＃39;无论城市过滤器如何，我都会获得所有制造商名单。

幸运的是，我得到了与我的场景相匹配的W3school SQL样本。 What is the difference between == vs equals() in Java?

SQL查询：

SELECT o.OrderId, p.ProductName, s.* 
FROM [Orders] o 
JOIN OrderDetails od ON o.OrderId = od.OrderId AND o.orderId = 10248 
JOIN Products p ON od.ProductId = p.ProductId
JOIN Suppliers s ON p.SupplierId = s.SupplierId and s.City ='Singapore'

Answer 1

我会压扁所有内容，然后只过滤你想要的城市：

class Manufacturer
{
    public string Name;
    public string Address;
    public string City;
}

class Product
{
    public Manufacturer[] Manufacturers;
}

class Order
{
    public Product[] Products;
}

static void Main(string[] args)
{
    var cities = new string[] { "a", "b" };
    Order[] orders = null;
    orders.SelectMany(o => o.Products.SelectMany(p => p.Manufacturers.Select(m => new { o, p, m })))
        .Where(g => cities.Contains(g.m.City))
        .ToList();
    }

或者，如果您想要返回新 Order（因为它们有不同的Products，它必须指向新分配的Object）您可以改为：

var newOrders = orders.Select(o => new Order()
{
    Products = o.Products
    .Select(p => new Product()
    {
        Manufacturers = p.Manufacturers.Where(m => cities.Contains(m.City)).ToArray()
    })
    .Where(m => m.Manufacturers.Length > 0).ToArray()
}).Where(p => p.Products.Length > 0).ToArray();

Answer 2

您正在应用错误的城市过滤器。就是这条线。

where t.Manufacturers.Any(v => v.City == "Hartford")

Any返回true，至少有一家制造商拥有City的财产作为＆＃34; Hartford＆＃34;所以基本上你的查询是这样的

var filteredOrders = from o in Orders
                from t in o.Products                           
                where true//←This is the problem
                select o;

你需要做的事实上是

where t.Manufacturers.City == "Hartford"

我希望这会有所帮助

示例：

var cityNames = new List<string> {"New York",
                                  "Atlanta",
                                  "Hartford",
                                  "Chicago"
                                  };
var anyResult = cityNames.Any(x=>x== "Hartford"); //TRUE
var whereResult = cityNames.Where(x => x == "Hartford"); //IEnumerable<string>, in this case only one element

Answer 3

我无法想到一种可以完全避免创建新对象的方法，因为无法直接过滤父对象的list属性。你可以使用同一个类。

另外，我使用两个单独的查询来在父/祖父对象中创建一个新列表。

我做了一个小演示来演示这个想法（下面有相同的代码）： http://ideone.com/MO6M6t

我尝试选择的城市是"tmp"，仅在父p3下，只属于祖父g1，g3

预期输出为：

g1
    p3
        tmp

g3
    p3
        tmp

using System;
using System.Collections.Generic;
using System.Linq;

public class Test
{
    public class GrandParent{
        public List<Parent> parentList{ get; set; }
        public string name{ get; set; }
        public GrandParent(string name){
            this.name = name;
            this.parentList = new List<Parent>();
        }
    }
    public class Parent{
        public List<Child> childList{ get; set;}
        public string name{ get; set; }
        public Parent(string name){
            this.name = name;
            this.childList = new List<Child>();
        }
    }
    public class Child{
        public string city{ get; set;}
        public Child(string city){
            this.city = city;
        }
    }
    public static void Main()
    {
        Child c1 = new Child("ABC"), c2 = new Child("123"), c3 = new Child("tmp");
        Parent p1 = new Parent("p1"), p2 = new Parent("p2"), p3 = new Parent("p3");
        GrandParent g1 = new GrandParent("g1"), g2 = new GrandParent("g2"), g3 = new GrandParent("g3");

        p1.childList.Add(c1); p1.childList.Add(c2); 
        p2.childList.Add(c2); 
        p3.childList.Add(c3);

        g1.parentList.Add(p1); g1.parentList.Add(p2); g1.parentList.Add(p3);
        g2.parentList.Add(p2);
        g3.parentList.Add(p3);

        List<GrandParent> repo = new List<GrandParent>{g1, g2, g3};

        var filteredParents = from g in repo
                              from p in g.parentList
                              where p.childList.Any(c => c.city == "tmp")
                              select new Parent(p.name){
                                 childList = p.childList.Where(c => c.city == "tmp").ToList()
                              };

        var filteredGrandParents = from g in repo
                                   from p in g.parentList
                                   where filteredParents.Any(fp => fp.name == p.name)
                                   select new GrandParent(g.name){
                                       parentList = g.parentList.Where(pp => filteredParents.Any(fp => fp.name == pp.name)).ToList()
                                   };

        foreach(var g in filteredGrandParents){
            Console.WriteLine(g.name);
            foreach(var p in g.parentList){
                Console.WriteLine("\t" + p.name);
                foreach(var c in p.childList){
                    Console.WriteLine("\t\t" + c.city);
                }
            }
            Console.WriteLine();
        }
    }
}

Answer 4

我终于尝试将所有内容放在一起并获得了预期的输出。

var fp = orders.Select(o =>
            {
                o.products = o.products.Select(p =>
                {
                    p.manufacturers.RemoveAll(m => m.City != "Hartford");
                    return p;
                }).ToList();

                return o;
            });

请建议是否有人有更好的解决方案

C＃LINQ嵌套选择查询

4 个答案: