In this article, we’ll explore flattening nested collections in C#. We’ll examine different approaches for handling from simple to complex data structures, offering practical guidance to effectively flatten nested collections within our C# applications.
Let’s get started.
Importance of Flattening Nested Collections
Nested collections can introduce unnecessary complexity, making it challenging to work with the data. Flattening these collections can simplify the structure, making it easier to understand and manipulate.
Also, organizing related records into a single, cohesive structure can lead to more efficient data storage and processing.
Moreover, by restructuring nested collections into a more linear format, we represent the data in a tabular format, which might be necessary for input in a database or integration with external systems.
Use of Select() Method to Flatten Specific Property
We will use as an example the department structure along with employees as nested collections. Let’s inspect the Department
record:
public record Department(string Name, IEnumerable<Employee> Employees);
We include only two properties, a string
for its Name
and the nested collection of Employee
objects. The constructor defined within the record syntax we use is a primary constructor. In C#, a primary constructor is a concise way to define a constructor that initializes the properties of a record
. Similarly, we design the Employee
record:
public record Employee(string Name, string Email);
For simplicity, here we include only the employee’s name and an email. Next, we initialize a Department
entity:
var department = new Department( "Human Resources", [ new("Alice", "[email protected]"), new("Bob", "[email protected]" ) ] );
The Department
record is the parent entity, while the Employee
record is the child. One Department
consists of one or more Employee
entities. Next, we will create the entity we are expecting to receive as a result:
public record DepartmentFlattened(string DepartmentName, string EmployeeName, string EmployeeEmail);
This object includes all properties of every other object at the same level. Now, let’s build a simple method for flattening the parent Department
object:
public static IEnumerable<DepartmentFlattened> FlattenWithSelect(Department department) { return department?.Employees?.Select(employee => new DepartmentFlattened( department.Name, employee.Name, employee.Email ) ); }
Our method FlattenWithSelect()
takes as input a Department
object and returns a collection of DepartmentFlattened
object. We use the LINQ syntax and the Select()
method to iterate over the Employee
object collection within the provided Department
.
For each Employee
, we construct a new DepartmentFlattened
object that includes every property value such as the DepartmentName
, EmployeeName
, and EmployeeEmail
. Consequently, we transform the entity into a flattened format by projecting these selected properties into a sequence of the objects we desire.
Finally, we can flatten our nested department
variable with the FlattenWithSelect()
method:
{ DepartmentName = Human Resources, EmployeeName = Alice, EmployeeEmail = [email protected] } { DepartmentName = Human Resources, EmployeeName = Bob, EmployeeEmail = [email protected] }
We can verify that the outcome includes every combination of the objects. We have a list of two Employee
objects from one Department
. So, the flattened objects are two in total, containing all the available properties.
Let’s see a different syntax now:
public static IEnumerable<DepartmentFlattened> FlattenWithQueryExpression(Department department) { return from employee in department?.Employees ?? [] select new DepartmentFlattened(department.Name, employee.Name, employee.Email); }
This time, we use query expression, a SQL-like syntax for composing queries over collections. In brief, it allows us to express operations in a more readable way.Â
As we expect, the method FlattenWithQueryExpression()
method performs the same.Â
Flatten Multiple Nested Collections With SelectMany()
Now, we will make the scenario a little bit more complex. We will add one more nested collection property to the Department
object, called Project
:
public record Project(string Title, int Budget);
The Project
record consists of a string
property name Title
and an int
property name Budget
, for demonstration purposes. Also, we extend the result object:
public record DepartmentFlattenedMultipleCollections( string DepartmentName, string EmployeeName, string EmployeeEmail, string ProjectTitle, int ProjectBudget );
Here, we add the string
property ProjectTitle
and int
property ProjectBudget
in order to include every combination. Now, we can build the new Department
object:
var department = new Department( "Engineering", [ new("Charlie", "[email protected]"), new("David", "[email protected]") ], [ new("Product Development", 50000), new("Research", 20000) ] );
We add two Project
object and two Employee
object instances in the Department
entity. Next, we can define a new method to flatten the Department
object:
public static IEnumerable<DepartmentFlattenedMultipleCollections>? FlattenWithSelectMany(Department department) { return department?.Employees?.SelectMany( employee => department.Projects.Select(project => new DepartmentFlattenedMultipleCollections( department.Name, employee.Name, employee.Email, project.Title, project.Budget ) ) ); }
In our FlattenWithSelectMany()
method, we aim to simplify the complex structure of a Department
object by using LINQ’s SelectMany()
method. For every Employee
in the Employees
collection, we iterate over all Projects
in the Projects
collection. Consequently, this allows us to construct a new object for each combination of Employee
and Project
. Within each object, we include all the properties that are present.
When we apply to a collection of collections, the SelectMany()
method projects each element of the outer collection to an inner collection. It is similar to a cross-join operation in SQL.Â
Let’s see the outcome:
{ DepartmentName = Engineering, EmployeeName = Charlie, EmployeeEmail = [email protected], ProjectTitle = Product Development, Budget = 50000 } { DepartmentName = Engineering, EmployeeName = Charlie, EmployeeEmail = [email protected], ProjectTitle = Research, Budget = 20000 } { DepartmentName = Engineering, EmployeeName = David, EmployeeEmail = [email protected], ProjectTitle = Product Development, Budget = 50000 } { DepartmentName = Engineering, EmployeeName = David, EmployeeEmail = [email protected], ProjectTitle = Research, Budget = 20000 }
Now, we can see that we have all possible combinations between collection properties in the result.Â
How to Flatten Two-Level Nested Collection
Now we will proceed with flattening an object that has a nested collection inside another one. Let’s enhance the Employee
object with the Certification
property:
public record Employee( string Name, string Email, IEnumerable<Certification>? Certifications = null );
The Employee
object includes a list of Certification
objects. Likewise, our next modification is about the result object we want as the outcome:
public record DepartmentFlattenedComplex( string DepartmentName, string EmployeeName, string EmployeeEmail, string CertificationTitle, DateOnly CertificationIssueDate );
In contrast to the previous similar object, we now have the string
property CertificationTitle
and the DateOnly
property CertificationIssueDate
. Respectively, we implement the method that handles this case:
public static IEnumerable<DepartmentFlattenedComplex>? FlattenComplexWithSelectMany(Department department) { return department?.Employees?.SelectMany( employee => employee.Certifications?.Select(certification => new DepartmentFlattenedComplex( department.Name, employee.Name, employee.Email, certification.Title, certification.IssueDate ) ) ); }
Initially, we navigate through the Employee
object collection within the provided Department
. For each Employee
, we utilize the SelectMany()
method to go through the Certification
collection of that Employee
. Lastly, within the inner Select()
method, we project each Certification
into the final object containing all properties to create a flat structure.
Now let’s examine the result:
{ DepartmentName = Engineering, EmployeeName = Charlie, EmployeeEmail = [email protected], Title = MCSD, IssueDate = 4/15/2020 } { DepartmentName = Engineering, EmployeeName = Charlie, EmployeeEmail = [email protected], Title = PMP, IssueDate = 3/1/2022 } { DepartmentName = Engineering, EmployeeName = David, EmployeeEmail = [email protected], Title = Solutions Architect, IssueDate = 7/5/2017 } { DepartmentName = Engineering, EmployeeName = David, EmployeeEmail = [email protected], Title = CCNA, IssueDate = 10/1/2019 }
We now project every Employee
and Certification
at the level of the parent Department
object.Â
To summarize, we can effectively flatten any nested collection hierarchy by utilizing multiple SelectMany()
operations. With each SelectMany()
call, we iterate over a nested collection within the parent collection, transforming it into a flat structure. Thus, by chaining multiple SelectMany()
calls, each targeting a different nested collection level, we progressively flatten the entire hierarchy into a single sequence of desired elements.Â
It is worth mentioning that apart from LINQ usage, we can also accomplish object flattening using the AutoMapper (or similar) libraries. We can set up rules that instruct the AutoMapper
mechanism how to convert from a complex, nested object and place it into a simpler, flat object.
Conclusion
In this article, we showcase solutions for flattening nested collections in objects. We examined from simple to complex cases, also demonstrating different syntax approaches.