{"id":42193,"date":"2023-09-07T17:31:43","date_gmt":"2023-09-07T17:31:43","guid":{"rendered":"https:\/\/stackify.com\/?p=42193"},"modified":"2024-06-07T08:23:39","modified_gmt":"2024-06-07T08:23:39","slug":"the-linq-join-operator-a-complete-tutorial","status":"publish","type":"post","link":"https:\/\/stackify.com\/the-linq-join-operator-a-complete-tutorial\/","title":{"rendered":"The LINQ Join Operator: A Complete Tutorial"},"content":{"rendered":"\n

I think most C# developers would agree that LINQ is an integral part of the experience of writing code with the language. LINQ provides a fluent, intuitive, and consistent way to query data sets. In this post, we’ll help in your LINQ-mastering quest by covering the LINQ join operator.<\/p>\n\n\n\n

We’ll start the post with a definition of LINQ itself, so we’re all on the same page. After that, you\u2019ll see an explanation of join operations in LINQ. Then, it’s time to roll up your sleeves and get practical with our hands-on guide to the join operator.<\/p>\n\n\n\n

Let’s get started.<\/p>\n\n\n\n

What is LINQ?<\/strong><\/h2>\n\n\n\n

LINQ<\/a> stands for Language Integrated Query. It’s a C# feature that offers a unique and consistent syntax for query datasets, regardless of their origin. The main benefit of LINQ is that you can use the same syntax to query data in memory, from a database, XML files, and so on.<\/p>\n\n\n\n

LINQ is available in two different flavors, the query syntax and the method syntax.<\/strong><\/p>\n\n\n\n

The query syntax leverages special keywords to create a syntax that is familiar to anyone who’s worked with SQL. Here’s an example that queries a sequence of numbers, filtering the ones greater than 5:<\/p>\n\n\n\n

int[] numbers = { 2, 8, 4, 9, 3, 6, 1, 7, 5 };\n
var largerThanFive = from num in numbers    where num > 5    select num;<\/p><\/code><\/pre>\n\n\n\n
The method syntax allows you to use extension methods to perform the same query:<\/p>\n\n\n\n
int[] numbers = { 2, 8, 4, 9, 3, 6, 1, 7, 5 };\nvar largerThanFive = numbers.Where(x => x > 5);\n<\/code><\/pre>\n\n\n\n
\"\"<\/figure>\n\n\n\n
What is The LINQ Join Operator?<\/strong><\/h2>\n\n\n\n
When working with data, a common scenario is having two data sources that you want to combine based on some criteria. For instance, you might have a Books table and an Authors table in your database, with a one-to-many relationship between them\u2014i.e., an author can author many books, but each book has only one author. If you need to compile a list of books containing their author’s name, you’d need to perform a join in order to match each line from the Books table to its counterpart in the Authors table.<\/p>\n\n\n\n
A join in LINQ is essentially the same: an operation where you can merge two collections according to some criteria you define.<\/p>\n\n\n\n
The LINQ Join Operator in Practice<\/strong><\/h2>\n\n\n\n
Examples always make things clearer. So, let’s see how to use the join operator in practice.<\/p>\n\n\n\n
Starting With a Problem<\/strong><\/h3>\n\n\n\n
Let’s say you have an e-commerce application with some data on categories:<\/p>\n\n\n\n
Id<\/strong><\/td>Name<\/strong><\/td><\/tr>
1<\/td>Electronics<\/td><\/tr>
4<\/td>Toys<\/td><\/tr>
5<\/td>Stationery<\/td><\/tr>
7<\/td>Books<\/td><\/tr>
10<\/td>Clothes<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Okay, now let’s have some products:<\/p>\n\n\n\n
Id<\/strong><\/td>Name<\/strong><\/td>Category_Id<\/strong><\/td><\/tr>
1<\/td>Amazon Kindle<\/td>1<\/td><\/tr>
2<\/td>Refactoring<\/td>7<\/td><\/tr>
3<\/td>C# in Depth<\/td>7<\/td><\/tr>
4<\/td>Legal Pad 50 sheets<\/td>5<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
You can see where this is leading, right? The next thing you’d want to do is to produce a single collection, having the list of products and the names of the categories they belong to. In other words, a view like this:<\/p>\n\n\n\n
Id<\/strong><\/td>Name<\/strong><\/td>Category<\/strong><\/td><\/tr>
1<\/td>Amazon Kindle<\/td>Electronics<\/td><\/tr>
2<\/td>Refactoring<\/td>Books<\/td><\/tr>
3<\/td>C# in Depth<\/td>Books<\/td><\/tr>
4<\/td>Legal Pad 50 sheets<\/td>Stationery<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Solving The Problem: Performing a LINQ Inner Join<\/strong><\/h3>\n\n\n\n
What would that operation look like in code? First of all, we need code to represent our categories and products. Thanks to C#’s record feature, two lines of code suffice for that:<\/p>\n\n\n\n
public record Product(int Id, string Name, int CategoryId);\npublic record Category(int Id, string Name);<\/code><\/pre>\n\n\n\n
Now, let’s have a list of each type:<\/p>\n\n\n\n
var categories = new List<Category>\n{\n    new Category(1, \"Electronics\"),\n    new Category(4, \"Toys\"),\n    new Category(5, \"Stationery\"),\n    new Category(7, \"Books\"),\n    new Category(10, \"Clothes\")\n};\n\nvar products = new List<Product>\n{\n    new Product(1, \"Amazon Kindle\", 1),\n    new Product(2, \"Refactoring\", 7),\n    new Product(3, \"C# In Depth\", 7),\n    new Product(4, \"Legal Pad 50 Sheets\", 5),\n    new Product(5, \"Surgical Gloves\", 12)\n};<\/code><\/pre>\n\n\n\n
As you can see, the list of products has an additional product (surgical gloves) whose category id doesn’t match any of the available categories. Keep this in mind; it’ll be relevant in a moment.<\/p>\n\n\n\n
Now, let’s write code to perform this join. I’ll show the code in one go and then explain it:<\/p>\n\n\n\n
var query =\n    from p in products\n    join c in categories\n    on p.CategoryId equals c.Id\n    select new\n    {\n        Id = p.Id,\n        Name = p.Name,\n        Category = c.Name\n    };\n\nforeach (var line in query)\n{\n    Console.WriteLine(line);\n}<\/code><\/pre>\n\n\n\n
Now, the explanation:<\/p>\n\n\n\n