C# Language SI UNISCE


Esempio

I join vengono utilizzati per combinare diversi elenchi o tabelle contenenti i dati tramite una chiave comune.

Come in SQL, i seguenti tipi di join sono supportati in LINQ:
Giunzioni esterne interne, a sinistra, a destra, a croce e complete .

I seguenti due elenchi sono utilizzati negli esempi seguenti:

var first = new List<string>(){ "a","b","c"}; // Left data
var second = new List<string>(){ "a", "c", "d"}; // Right data

(Interno) Unisciti

var result = from f in first
             join s in second on f equals s
             select new { f, s };

var result = first.Join(second, 
                        f => f, 
                        s => s,
                        (f, s) => new { f, s });

// Result: {"a","a"}
//         {"c","c"}

Giuntura esterna sinistra

var leftOuterJoin = from f in first
                    join s in second on f equals s into temp
                    from t in temp.DefaultIfEmpty()
                    select new { First = f, Second = t};

// Or can also do:
var leftOuterJoin = from f in first
                    from s in second.Where(x => x == f).DefaultIfEmpty()
                    select new { First = f, Second = s};

// Result: {"a","a"}
//         {"b", null}  
//         {"c","c"}  


// Left outer join method syntax
var leftOuterJoinFluentSyntax = first.GroupJoin(second,
                                      f => f,
                                      s => s,
                                      (f, s) => new { First = f, Second = s })
                                   .SelectMany(temp => temp.Second.DefaultIfEmpty(),
                                      (f, s) => new { First = f.First, Second = s });

Giusto outer join

var rightOuterJoin = from s in second
                     join f in first on s equals f into temp
                     from t in temp.DefaultIfEmpty()
                     select new {First=t,Second=s};

// Result: {"a","a"}
//         {"c","c"}  
//         {null,"d"}  

Cross Join

var CrossJoin = from f in first
                from s in second
                select new { f, s };

// Result: {"a","a"}
//         {"a","c"}  
//         {"a","d"}  
//         {"b","a"}
//         {"b","c"}  
//         {"b","d"}  
//         {"c","a"}
//         {"c","c"}  
//         {"c","d"}

Full Outer Join

var fullOuterjoin = leftOuterJoin.Union(rightOuterJoin);

// Result: {"a","a"}
//         {"b", null}  
//         {"c","c"}  
//         {null,"d"}

Esempio pratico

Gli esempi sopra hanno una struttura dati semplice in modo che tu possa concentrarti sulla comprensione dei diversi LINQ che si uniscono tecnicamente, ma nel mondo reale avresti tabelle con colonne a cui devi unirti.

Nell'esempio seguente, vi è una sola Region classe utilizzata, in realtà si unirebbero due o più tabelle diverse che contengono la stessa chiave (in questo esempio, il first e il second vengono uniti tramite l' ID chiave comune).

Esempio: considerare la seguente struttura di dati:

public class Region 
{
    public Int32 ID;
    public string RegionDescription;
    
    public Region(Int32 pRegionID, string pRegionDescription=null)
    {
        ID = pRegionID; RegionDescription = pRegionDescription;
    }
}

Ora prepara i dati (cioè compila con i dati):

// Left data
var first = new List<Region>() 
                 { new Region(1), new Region(3), new Region(4) }; 
// Right data
var second = new List<Region>() 
                 { 
                    new Region(1, "Eastern"),  new Region(2, "Western"),
                    new Region(3, "Northern"), new Region(4, "Southern")
                 }; 

Puoi vedere che in questo esempio first non contiene alcuna descrizione di regione, quindi vuoi unirti a loro dal second . Quindi l'unione interna sarebbe simile a:

// do the inner join
var result = from f in first
             join s in second on f.ID equals s.ID
             select new { f.ID, s.RegionDescription };


 // Result: {1,"Eastern"}
 //         {3, Northern}  
 //         {4,"Southern"}  

Questo risultato ha creato oggetti anonimi al volo, il che va bene, ma abbiamo già creato una classe appropriata, quindi possiamo specificarla: invece di select new { f.ID, s.RegionDescription }; possiamo dire select new Region(f.ID, s.RegionDescription); , che restituirà gli stessi dati ma creerà oggetti di tipo Region , che manterranno la compatibilità con gli altri oggetti.

Demo live su .NET fiddle