0

我已经研究了几个小时，我得到的唯一结论是我需要拿起一本关于 Linq 的好书。

所以这是交易：我有以下类的三个对象列表（从现在开始我将它们称为“父列表”：

    public class State
    {
        public int IdState {get; set;}
        public string NameState {get; set;}
        private IList<City> cityList = new List<City>();

        public void AddCity(City city)
        {
            cityList.Add(city);
        }
    }

    public class City
    {
        public int IdCity { get; set; }
        public string NameCity { get; set; }
        public int IdState { get; set; }
        private IList<Company> companyList = new List<Company>();

        public void AddCompany(Company company)
        {
            companyList.Add(company);
        }
    }

    public class Company
    {
        public int IdCompany { get; set; }
        public string NameCompany { get; set; }
        public int IdCity { get; set; }
    }

我认为从这里可以很直接地解释我想要什么：一个州列表，其中 cityList 填充了该州的适当城市，每个城市中的每个 companyList 列表都填充了该城市的公司。换句话说，一个州列表，每个州分支到其城市，然后每个城市分支到其中的公司。

所以，我的父母名单是：

    private List<State> finalList; //This is the "parent list supreme" which I'll send to the client-side
    private List<City> cityList; //Auxiliary
    private List<Company> companyList; //Auxiliary; this one does not exist in the actual code but I'm putting it here for simplification purposes

真的没关系，但多亏了 linq“魔法”，我能够用正确的州、城市和公司填写这些列表，但是，我不知道如何填写正确的城市和公司通过链接进入 State.cityList 和 City.companyList。就目前而言，我正在使用一个非常丑陋的 foreach 链：

        foreach (State state in finalList)
        {
            foreach (City city in cityList)
            {
                if (city.IdState == state.IdState)
                {
                    state.AddCity(city);

                    foreach (Company company in companyList)
                    {
                        if (company.idCity == city.IdCity)
                            city.AddCompany(company);
                    }
                }
            }
        }

丑陋，对吧？那么，我该如何用 linq 实现同样的目标呢？我认为也许是一个更有效的问题：在这种情况下是否值得使用 linq（它都指向“是”但数字......）？

顺便说一句：这种方式正如我所料

4

3 回答 3

2

你在这里合乎逻辑地做的是一个 Join 操作。您当前的代码实际上是查找所有可能的城市和州对，然后仅归档匹配的对。您可以在 LINQ 中表示这一点，但您不想这样做。有更有效的方法来执行只生成您需要开始的确切对的连接。LINQJoin运算符利用了这一点。

您的代码归结为两个不同Join的调用，然后对每个结果进行迭代，根据查询执行对象的突变。

var stateCityPairs = from state in finalList
                        join city in cityList
                        on state.IdState equals city.IdState
                        select new { state, city };

foreach (var pair in stateCityPairs)
    pair.state.AddCity(pair.city);


var cityCompanyPairs = from city in cityList
                        join company in companyList
                        on city.IdCity equals company.IdCity
                        select new { city, company };

foreach (var pair in cityCompanyPairs)
    pair.city.AddCompany(pair.company);

虽然这实际上是一个多一点的代码，但这对于更大的集合会执行得更好一些，并且在语义上也代表了你的代码的意图是什么。

于 2013-08-22T19:51:49.710 回答
1

我在 City 和 State 类中添加了 2 个方法。如果列表是公开的，那就更容易了：

public void AddCities(List<City> cities)
{
    cityList.Concat(cities);
}

public void AddCompanies(List<Company> companies)
{
    companyList.Concat(companies);
}

您可以使用所需的聚合器。我通常更喜欢 Union 因为它不会添加双打，但我想这对你来说并不重要。

她是我在 Linq 中的做法：

cityList.ForEach(ci => ci.AddCompanies(companyList.Where(co => co.IdCity == ci.IdCity).ToList()));
finalList.ForEach(s => s.AddCities(cityList.Where(ci => ci.IdState == s.IdState).ToList()));

我首先将公司添加到正确的城市，然后添加正确状态的所有城市。如果您需要有关此代码的更多说明，请随时询问。

于 2013-08-22T20:07:45.090 回答
0

使用 LINQ，您可能希望将私有 IList 转换为公共 IList（或 List 或 IEnumerable 或 IQueryable），以便您可以直接设置它们。

假设 finalList 已经预先填充了州：

var finalList=finalList
    .Select(fl=>new State
    {
        fl.IdState,
        fl.NameState,
        cityList=cityList.Where(cl=>cl.IdState==fl.IdState).Select(cl=>
            new City
            {
                cl.IdCity,
                cl.NameCity,
                cl.IdState,
                companyList=companyList.Where(comp=>
                    comp.IdState==cl.IdState && comp.IdCity==cl.IdCity)
            }
    });
于 2013-08-22T20:00:17.713 回答