Question

我具有如下的类属性

public class Country
{
   CountryId,
   CountryName,
   List<State>
}

Public class State
{
   StateId,
   StateName,
   List<City>
}

Public class City
{
   CityId,
   CityName
}

我为每个类设置了数据集，这些数据集如下所示从DB中提取数据。

CountryDS  
`````````  
CountryId | CountryName
1         | India  
2         | China  

StateDS  
```````  
CountryId | StateId | StateName  
1         | 1       | UP  
1         | 2       | MP  
1         | 3       | Punjab  
2         | 10      | Beijing  

CityDS  
``````  
StateId | CityId | CityName  
1       | 1      | Agra  
1       | 2      | Mathura  
2       | 5      | Ujjain  
2       | 7      | Dewas  
3       | 10     | Amritsar

现在，我想将这些数据集转换为List<Country>对象，而无需嵌套循环或LinQ或快速提取数据的最佳方法。

Country  
--> CountryId  
    CountryName  
    State  
    --> StateId  
        StateName  
        City  
        --> CityId  
            CityName

Answer 1

如果不使用LinQ或嵌套循环，则可以通过一个小的解决方法来实现。

将您的数据集转换为JSON。
将JSON解析为适当的对象。

您可以使用newtonsoft进行序列化或反序列化。

Answer 2

...但是创建对象需要很长时间，因为我有数以百万计的记录，因为在一个国家中可以有很多州，在一个州中可以有很多城市。所以我想用Linq是否有办法。

请注意，LINQ已针对重用进行了优化，而不是针对快速代码。 LINQ内部将使用foreach，这将调用GetEnumerator()和MoveNext()。专为您的解决方案设计的foreach可能比LINQ foreach更快，并且您可以通过调用枚举自己（GetEnumerator和MoveNext）来进行更多优化。 / p>

不过，如果您想使用LINQ，则每当您想要带有子对象（通常带有外键）的对象时，例如学校与学生，图书馆与书籍，国家与州，Enumerable.Groupjoin是要走的路。

因此，您有三个集合，使用主键和外来kesy指向彼此：

IEnumerable<Country> countries = ...
IEnumerable<State> states = ...
IEnumerable<City> cities = ...

您想要收集国家/地区，以及每个国家/地区都有其城市的国家/地区。

var result = countries.GroupJoin(states,  // GroupJoin countries and states
   country => country.Id,                 // from the country take the primary key
   state => state.CountryId               // from the state take the foreign key
   (country, statesOfCountry) => new      // from every country with all its states
   {                                      // make one new object
       Id = country.Id,                   // cointaining only the properties you plan to use
       Name = country.Name,
       ...

       States = ...                       // see below
   }

要计算States of every country with their cities，我们用匹配的主键和外键Groupjoin和statesOfCountry集合cities：

继续上述LINQ：

States = statesOfCountry.GroupJoin(cities,   // Groupjoin states with cities
   stateOfCountry => stateOfCountry.Id,      // from every state take the Id
   city => city.StateId,                     // from every city take the stateId
   (stateOfCountry, citiesOfState) => new    // again: when they match make a new object
   {
        // for performance: select only the properties yo actually plan to use
        Id = stateOfCountry.Id,
        Name = stateOfCountry.Name,

        // not needed: you know it equals Country.Id:
        // CountryId = stateOfCountry.CountryId,

        Cities = citiesOfState.Select(city => new
        {
             // only the properties you plan to use
             Id = city.Id,
             Name = city.Name,
             Location = city.Location,

             // not needed, you already know the value:
             // StateId = city.StateId,
        }),
   }

令人高兴的是，您仅创建了一个可枚举的对象，即：您仅创建了知道如何枚举的对象。您尚未枚举。这样做的好处是速度非常快，如果在枚举过程中您决定不需要某些信息，则不必枚举它。

例如，一旦您开始枚举，并且您想忽略所有城市，俄罗斯城市：

foreach (var country in result)
{
     if (country.Name != "Russia")
        ProcessCountry(country);
     // else: ignore

这样做的好处是不会执行俄罗斯城市的GroupJoin

将数据集转换为通用列表

2 个答案: