Click here to Skip to main content
15,867,453 members
Articles / Programming Languages / C#

LINQ Extended Joins

Rate me:
Please Sign up or sign in to vote.
4.95/5 (173 votes)
22 Apr 2017CPOL5 min read 232.8K   4.6K   263   74
The lost joins in System.Linq

Introduction

The very first time that I was interested by LinQ, there in 2007, apart from the great admiration for the product and the whole range of possibilities that it was before me, there was something that I really missed something that, for a SQL developer with a “wide” range of knowledge, was difficult to understand about the new philosophy for queries over objects. It was nothing more than the absence of many of the SQL joins advanced sentences within the LinQ basis class extensive methods.

At the beginning, I assumed that the problem was a matter of time for the Microsoft Developer team and that it will be fixed in the next versions. But, the deeper I analysed the product, the more I realized that maybe it was not the better way to work for an object oriented developer and that it was needed to leave apart the solutions given for a database professional worker since they may be useful for them but not so valid for us. This was remarked even more at the time I knew about Entity Framework browsing properties.

To this day, I learnt that anything is black or white but the main point is to be useful, that some solutions do not fit 100% with the pureness of the development premises but they are very handy and save time and money, which is essential in the daily work for a great developer. We can find some examples of it within the Framework (Extensive methods, anonymous types, dynamics, etc.)

Background

Some years ago, I read an article by C. L. Moffatt (link) where he explained, in a very clear and concise way, the types of joins in SQL and the idea of writing a similar article for LinQ has been going round and round in my head since then. Now I've decided to do it.

I have seen many questions and answers about this topic in the forums but I couldn't find any which embrace it all. It is my intention to overcome these missing topics with the next lines.

This article only tries to be a didactic paper but also tries to make others´ life easier by adding a sample project where everything mentioned in the article has been applied. In addition, an extension class that will be useful for those who don´t want to spent too much time coding each and every concept has been added.

Installation

LinQ Extended Joins is an open source project and your code is available in Github.

Your installation is very simple, and we add a nuget package.

Image 1

Add the using MoralesLarios.Linq in the class to use.

Update Code

I have added a generic restriction in the extension method:

C#
where TSource : class where TInner : class

With this restriction, I have fixed the bug with use sequences not nullables.

Using the Code

I will use two classes, to demonstrate my examples:

C#
public class Person
{
    public string   ID        { get; set; }
    public string   Name      { get; set; }
    public int      Age       { get; set; }
    public double   Salary    { get; set; }
    public DateTime Born      { get; set; }
    public int      IdAddress { get; set; }
}

public class Address
{
    public int    IdAddress { get; set; }
    public string Street    { get; set; }
    public int    Num       { get; set; }
    public string City      { get; set; }
}    

These are the default values for the Person class:

Image 2

These are the default values for the Address class:

Image 3

My extension methods library has six extension methods. The main method INNER JOIN, was developed in the linq base library. The following methods will be explained:

  1. Inner Join
  2. Left Join
  3. Right Join
  4. Full Outer Join
  5. Left Join Excluding Inner Join
  6. Right Join Excluding Inner Join
  7. Full Outer Join Excluding Inner Join

Inner Join

Image 4

This is the main method. It has been implemented in the .NET Framework, so there is no extension method for it.

C#
var result = from p in Person.BuiltPersons()
             join a in Address.BuiltAddresses()
             on p.IdAddress equals a.IdAddress
             select new 
	   { 
                 Name             = a.MyPerson.Name,
                 Age              = a.MyPerson.Age,
                 PersonIdAddress  = a.MyPerson.IdAddress,
                 AddressIdAddress = a.MyAddress.IdAddress,
                 Street           = a.MyAddress.Street
	   };  

Lambda Expression:

C#
var resultJoint = Person.BuiltPersons().Join(                      /// Source Collection
                  Address.BuiltAddresses(),                        /// Inner Collection
                  p => p.IdAddress,                                /// PK
                  a => a.IdAddress,                                /// FK
                  (p, a) => new { MyPerson = p, MyAddress = a })   /// Result Collection
                  .Select(a => new
                    {
                        Name             = a.MyPerson.Name,
                        Age              = a.MyPerson.Age,
                        PersonIdAddress  = a.MyPerson.IdAddress,
                        AddressIdAddress = a.MyAddress.IdAddress,
                        Street           = a.MyAddress.Street
                    });  

As we can see, the extension method has five main parts that will be shared for the rest of the extension methods:

  1. is the main Collection
  2. is the inner Collection
  3. is the PK
  4. is the FK
  5. is the type for the result collection

Results of the previous query:

Image 5

As we can see, PersonIdAddresses values match with the AddressIdAddresses.

Left Join

Image 6

Extension method:

C#
public static IEnumerable<TResult> 
	LeftJoin<TSource, TInner, TKey, TResult>(this IEnumerable<TSource> source,
                                                 IEnumerable<TInner> inner, 
                                                 Func<TSource, TKey> pk, 
                                                 Func<TInner, TKey> fk, 
                                                 Func<TSource, TInner, TResult> result)
                                      where TSource : class where TInner : class
{
    IEnumerable<TResult> _result = Enumerable.Empty<TResult>();
 
    _result = from s in source
              join i in inner
              on pk(s) equals fk(i) into joinData
              from left in joinData.DefaultIfEmpty()
              select result(s, left);
 
    return _result;
}  

Lambda expression:

C#
var resultJoint = Person.BuiltPersons().LeftJoin(                    /// Source Collection
                    Address.BuiltAddresses(),                        /// Inner Collection
                    p => p.IdAddress,                                /// PK
                    a => a.IdAddress,                                /// FK
                    (p, a) => new { MyPerson = p, MyAddress = a })   /// Result Collection
                    .Select(a => new
                    {
                        Name             = a.MyPerson.Name,
                        Age              = a.MyPerson.Age,
                        PersonIdAddress  = a.MyPerson.IdAddress,
                        AddressIdAddress = (a.MyAddress != null ? a.MyAddress.IdAddress : -1),
			Street           = (a.MyAddress != null ? a.MyAddress.Street    : "Null-Value")
                    }); 

We have to pay attention here, at the moment of call the select method and built our new result type, we must control the values returned by the Address class, because the returned object can be null, and in that case, the reading of any of its properties would throw a NullReferenceException.

Results of the previous query:

Image 7

Right Join

Image 8

Extension method:

C#
public static IEnumerable<TResult> 
	RightJoin<TSource, TInner, TKey, TResult>(this IEnumerable<TSource> source,
                                                  IEnumerable<TInner> inner,
                                                  Func<TSource, TKey> pk,
                                                  Func<TInner, TKey> fk,
                                                  Func<TSource, TInner, TResult> result)
                                     where TSource : class where TInner : class
{
    IEnumerable<TResult> _result = Enumerable.Empty<TResult>();
 
    _result  = from i in inner
                join s in source
                on fk(i) equals pk(s) into joinData
                from right in joinData.DefaultIfEmpty()
                select result(right, i);
 
    return _result;
}

Lambda expression:

C#
var resultJoint = Person.BuiltPersons().RightJoin(                   /// Source Collection
                    Address.BuiltAddresses(),                        /// Inner Collection
                    p => p.IdAddress,                                /// PK
                    a => a.IdAddress,                                /// FK
                    (p, a) => new { MyPerson = p, MyAddress = a })   /// Result Collection
                    .Select(a => new
                    {
                        Name           = (a.MyPerson != null ? a.MyPerson.Name : "Null-Value"),
                        Age              = (a.MyPerson != null ? a.MyPerson.Age : -1),
                        PersonIdAddress  = (a.MyPerson != null ? a.MyPerson.IdAddress : -1),
                        AddressIdAddress = a.MyAddress.IdAddress,
                        Street           = a.MyAddress.Street
                    }); 

Note that we must control null values in the Person class in order to avoid exceptions.

Results of the previous query:

Image 9

Full Outer Join

Image 10

Extension method:

C#
public static IEnumerable<TResult> 
	FullOuterJoinJoin<TSource, TInner, TKey, TResult>(this IEnumerable<TSource> source,
                                                          IEnumerable<TInner> inner,
                                                          Func<TSource, TKey> pk,
                                                          Func<TInner, TKey> fk,
                                                          Func<TSource, TInner, TResult> result)
                                                 where TSource : class where TInner : class
{
 
    var left = source.LeftJoin(inner, pk, fk, result).ToList();
    var right = source.RightJoin(inner, pk, fk, result).ToList();
 
    return left.Union(right);
} 

Lambda expression:

C#
var resultJoint = Person.BuiltPersons().FullOuterJoinJoin(           /// Source Collection
                    Address.BuiltAddresses(),                        /// Inner Collection
                    p => p.IdAddress,                                /// PK
                    a => a.IdAddress,                                /// FK
                    (p, a) => new { MyPerson = p, MyAddress = a })   /// Result Collection
                    .Select(a => new
                    {
                        Name             = (a.MyPerson  != null ? 
                                            a.MyPerson.Name       : "Null-Value"),
                        Age              = (a.MyPerson  != null ? 
                                            a.MyPerson.Age        : -1),
                        PersonIdAddress  = (a.MyPerson  != null ? 
                                            a.MyPerson.IdAddress  : -1),
                        AddressIdAddress = (a.MyAddress != null ? 
                                            a.MyAddress.IdAddress : -1),
                        Street           = (a.MyAddress != null ? 
                                            a.MyAddress.Street    : "Null-Value")
                    }); 

Note that we must control null values in both classes.

Results of the previous query:

Image 11

Left Excluding Join

Image 12

Extension method:

C#
public static IEnumerable<TResult> 
	LeftExcludingJoin<TSource, TInner, TKey, TResult>(this IEnumerable<TSource> source,
                                                          IEnumerable<TInner> inner,
                                                          Func<TSource, TKey> pk,
                                                          Func<TInner, TKey> fk,
                                                          Func<TSource, TInner, TResult> result)
                                            where TSource : class where TInner : class
{
    IEnumerable<TResult> _result = Enumerable.Empty<TResult>();
 
    _result = from s in source
                join i in inner
                on pk(s) equals fk(i) into joinData
                from left in joinData.DefaultIfEmpty()
                where left == null
                select result(s, left);
 
    return _result;
} 

Lambda expression

C#
var resultJoint = Person.BuiltPersons().LeftExcludingJoin(           /// Source Collection
                    Address.BuiltAddresses(),                        /// Inner Collection
                    p => p.IdAddress,                                /// PK
                    a => a.IdAddress,                                /// FK
                    (p, a) => new { MyPerson = p, MyAddress = a })   /// Result Collection
                    .Select(a => new
                    {
                        Name             = a.MyPerson.Name,
                        Age              = a.MyPerson.Age,
                        PersonIdAddress  = a.MyPerson.IdAddress,
                        AddressIdAddress = (a.MyAddress != null ? a.MyAddress.IdAddress : -1),
                        Street           = (a.MyAddress != null ? 
                                            a.MyAddress.Street    : "Null-Value")
                    }); 

Note that we must control null values in Address class.

Results of the previous query:

Image 13

 

Right Excluding Join

 

Image 14

Extension method:

C#
public static IEnumerable<TResult> 
     RightExcludingJoin<TSource, TInner, TKey, TResult>(this IEnumerable<TSource> source,
                                                        IEnumerable<TInner> inner,
                                                        Func<TSource, TKey> pk,
                                                        Func<TInner, TKey> fk,
                                                        Func<TSource, TInner, TResult> result)
                                              where TSource : class where TInner : class
{
    IEnumerable<TResult> _result = Enumerable.Empty<TResult>();
 
    _result = from i in inner
                join s in source
                on fk(i) equals pk(s) into joinData
                from right in joinData.DefaultIfEmpty()
                where right == null
                select result(right, i);
 
    return _result;
} 

Lambda expression:

C#
var resultJoint = Person.BuiltPersons().RightExcludingJoin(          /// Source Collection
                    Address.BuiltAddresses(),                        /// Inner Collection
                    p => p.IdAddress,                                /// PK
                    a => a.IdAddress,                                /// FK
                    (p, a) => new { MyPerson = p, MyAddress = a })   /// Result Collection
                    .Select(a => new
                    {
                        Name             = (a.MyPerson != null ? 
                                            a.MyPerson.Name      : "Null-Value"),
                        Age              = (a.MyPerson != null ? a.MyPerson.Age       : -1),
                        PersonIdAddress  = (a.MyPerson != null ? a.MyPerson.IdAddress : -1),
                        AddressIdAddress = a.MyAddress.IdAddress,
                        Street           = a.MyAddress.Street
                    }); 

Note that we must control null values in Person class.

Results of the previous query:

Image 15

Full Outer Excluding Join

Image 16

Extension method:

C#
public static IEnumerable<TResult> 
   FulltExcludingJoin<TSource, TInner, TKey, TResult>(this IEnumerable<TSource> source,
                                                      IEnumerable<TInner> inner,
                                                      Func<TSource, TKey> pk,
                                                      Func<TInner, TKey> fk,
                                                      Func<TSource, TInner, TResult> result)
                                       where TSource : class where TInner : class
{
    var left = source.LeftExcludingJoin(inner, pk, fk, result).ToList();
    var right = source.RightExcludingJoin(inner, pk, fk, result).ToList();
 
    return left.Union(right);
} 

Lambda expression:

C#
var resultJoint = Person.BuiltPersons().FulltExcludingJoin(          /// Source Collection
                    Address.BuiltAddresses(),                        /// Inner Collection
                    p => p.IdAddress,                                /// PK
                    a => a.IdAddress,                                /// FK
                    (p, a) => new { MyPerson = p, MyAddress = a })   /// Result Collection
                    .Select(a => new
                    {
                        Name             = (a.MyPerson  != null ? 
                                            a.MyPerson.Name       : "Null-Value"),
                        Age              = (a.MyPerson  != null ? 
                                            a.MyPerson.Age        : -1),
                        PersonIdAddress  = (a.MyPerson  != null ? 
                                            a.MyPerson.IdAddress  : -1),
                        AddressIdAddress = (a.MyAddress != null ? 
                                            a.MyAddress.IdAddress : -1),
                        Street           = (a.MyAddress != null ? 
                                            a.MyAddress.Street    : "Null-Value")
                    }); 

Note that we must control null values in both classes.

Results of the previous query:

Image 17

-- the Best Solution

I believe that is the best solution for a OOP developer.

C#
var GroupPersons = this.Persons.GroupJoin(this.Addresses,     /// Inner Collection
                                          p => p.IdAddress,   /// PK
                                          a => a.IdAddress,   /// FK
                                          (p, a) =>           /// Result Collection
                                          new { 
                                                  MyPerson  = p, 
                                                  Addresses = a.Select(ad => ad).ToList() 
                                               }).ToList();   

or:

C#
var GroupAddresses = this.Addresses.GroupJoin(this.Persons,         /// Inner Collection
                                              a => a.IdAddress,     /// PK
                                              p => p.IdAddress,     /// FK
                                              (a, p) =>             /// Result Collection
                                              new { 
                                                     MyAddress = a, 
                                                     Persons   = p.Select(ps => ps).ToList() 
                                                  }).ToList();   

Code for fill the treeview:

C#
foreach (var data in GroupPersons)
{
    TreeViewItem tbi = new TreeViewItem{ Header = data.MyPerson };
    this.treePersons.Items.Add(tbi);
    foreach (var d in data.Addresses)
    {
        TreeViewItem tbiChild = 
		new TreeViewItem { Header = d , Background = Brushes.Gainsboro };
        this.treePersons.Items.OfType<TreeViewItem>().Last().Items.Add(tbiChild);
    }                        
}    

or:

C#
foreach (var data in GroupAddresses)
{
    TreeViewItem tbi = new TreeViewItem{ Header = data.MyAddress };
    this.treeAddresses.Items.Add(tbi);
    foreach (var d in data.Persons)
    {
        TreeViewItem tbiChild = 
		new TreeViewItem { Header = d , Background = Brushes.Gainsboro };
        this.treeAddresses.Items.OfType<TreeViewItem>().Last().Items.Add(tbiChild);
    }                         
}    

Results:

Image 18

We change the IdAddress values, we must do that in order to see more clearly.

Image 19

Results:

Image 20

Application Testing

In the test application, we can change the values of the Person and Address collections, and choose the join to apply the changes will be applied on the result collections.

Image 21

Thanks

Thanks to Santiago Sánchez and Cesar Sanz for their English.

History

  • 4th November, 2012: Initial version

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


Written By
Software Developer (Senior) Cecabank
Spain Spain
MVP C# Corner 2017

MAP Microsoft Active Professional 2014

MCPD - Designing and Developing Windows Applications .NET Framework 4
MCTS - Windows Applications Development .NET Framework 4
MCTS - Accessing Data Development .NET Framework 4
MCTS - WCF Development .NET Framework 4

Comments and Discussions

 
GeneralRe: Left and Right Excluding fail if the type being used is not a class Pin
Juan Francisco Morales Larios13-Jun-17 20:25
Juan Francisco Morales Larios13-Jun-17 20:25 
GeneralRe: Left and Right Excluding fail if the type being used is not a class Pin
tbayart10-Feb-17 1:56
professionaltbayart10-Feb-17 1:56 
Questionno LEFTJOIN/RIGHTJOIN/FULLJOIN kewords available in linq Pin
Hemant P3-Jan-16 6:42
Hemant P3-Jan-16 6:42 
AnswerRe: no LEFTJOIN/RIGHTJOIN/FULLJOIN kewords available in linq Pin
Yoseph TX8-Jul-16 5:51
Yoseph TX8-Jul-16 5:51 
GeneralRe: no LEFTJOIN/RIGHTJOIN/FULLJOIN kewords available in linq Pin
Yoseph TX8-Jul-16 5:57
Yoseph TX8-Jul-16 5:57 
GeneralMy vote of 5 Pin
D V L13-Sep-15 19:22
professionalD V L13-Sep-15 19:22 
QuestionMy vote is 5 Pin
ocelot-it6-Feb-15 7:09
ocelot-it6-Feb-15 7:09 
QuestionVery Helpful Pin
Member 1132116318-Dec-14 7:36
Member 1132116318-Dec-14 7:36 
GeneralAwesome Pin
shahabj10-Dec-14 10:15
shahabj10-Dec-14 10:15 
GeneralMy vote of 5 Pin
srilekhamenon3-Nov-14 1:03
professionalsrilekhamenon3-Nov-14 1:03 
Bugthe same value is removed when full join Pin
b0sus10-May-14 15:49
b0sus10-May-14 15:49 
GeneralVery useful Linq joins article Pin
Naresh Kothur16-Apr-14 4:55
Naresh Kothur16-Apr-14 4:55 
QuestionIllustration is self explanatory Pin
moyeenm10-Mar-14 23:20
moyeenm10-Mar-14 23:20 
QuestionBeautifully crafted and written article. Pin
Nigel Shaw3-Feb-14 15:52
Nigel Shaw3-Feb-14 15:52 
QuestionMy vote of 5 Pin
PeterNguyen2-Jan-14 5:06
PeterNguyen2-Jan-14 5:06 
GeneralVery Nice Article Pin
ArpitNagar27-Oct-13 21:56
ArpitNagar27-Oct-13 21:56 
QuestionSuggest : Enumerate parameters to List Pin
aliCarryme16-Sep-13 2:28
aliCarryme16-Sep-13 2:28 
GeneralMy vote of 5 Pin
NidalNazer9-Jan-13 5:38
NidalNazer9-Jan-13 5:38 
GeneralMy vote of 5 Pin
Ștefan-Mihai MOGA14-Dec-12 5:10
professionalȘtefan-Mihai MOGA14-Dec-12 5:10 
QuestionVery nice Pin
BillW3312-Dec-12 5:12
professionalBillW3312-Dec-12 5:12 
GeneralMy vote of 5 Pin
Savalia Manoj M10-Dec-12 20:53
Savalia Manoj M10-Dec-12 20:53 
GeneralMy vote of 5 Pin
Md. Marufuzzaman9-Dec-12 0:55
professionalMd. Marufuzzaman9-Dec-12 0:55 
Questionmy 5! Pin
Mohammad A Rahman6-Dec-12 13:14
Mohammad A Rahman6-Dec-12 13:14 
QuestionHello from shiv Pin
Shivprasad koirala1-Dec-12 18:24
Shivprasad koirala1-Dec-12 18:24 
AnswerRe: Hello from shiv Pin
Juan Francisco Morales Larios10-Feb-17 12:21
Juan Francisco Morales Larios10-Feb-17 12:21 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.