ESQUERDA OUTER JOIN no LINQ

539

Como executar a junção externa esquerda no C # LINQ para objetos sem usar join-on-equals-intocláusulas? Existe alguma maneira de fazer isso com a wherecláusula? Problema correto: a junção interna é fácil e eu tenho uma solução como esta

List<JoinPair> innerFinal = (from l in lefts from r in rights where l.Key == r.Key
                             select new JoinPair { LeftId = l.Id, RightId = r.Id})

mas para a junção externa esquerda, preciso de uma solução. O meu é algo parecido com isto, mas não está funcionando

List< JoinPair> leftFinal = (from l in lefts from r in rights
                             select new JoinPair { 
                                            LeftId = l.Id, 
                                            RightId = ((l.Key==r.Key) ? r.Id : 0
                                        })

onde JoinPair é uma classe:

public class JoinPair { long leftId; long rightId; }
Brinquedo
fonte
2
você pode dar um exemplo do que você está tentando alcançar?
jeroenh
a junção externa esquerda normal é algo como isto: var a = de b na junção bb c em cc em b.bbbbb é igual a c.ccccc em dd a partir de d em dd.DefaultIfEmpty () selecione b.sss; A minha pergunta é que existe alguma maneira de fazer isso sem usar cláusulas de junção sobre iguais em algo como esta var a = de b em bb de c em cc em que b.bbb == c.cccc ... e assim por diante .. .
Toy
1
se há, mas você deve postar um exemplo do seu código que você já tem para que as pessoas podem dar-lhe uma resposta melhor
preguiça
Eu estava procurando por um JOIN "Esquerda excluindo " (e confundi com o conceito de "EXTERIOR"). Essa resposta estava mais próxima do que eu queria.
The Red Pea

Respostas:

598

Como indicado em:

101 amostras LINQ - junção externa esquerda

var q =
    from c in categories
    join p in products on c.Category equals p.Category into ps
    from p in ps.DefaultIfEmpty()
    select new { Category = c, ProductName = p == null ? "(No products)" : p.ProductName };
ajay_whiz
fonte
7
Estou tentando a mesma coisa, mas obtendo um erro no operador de junção, que diz "O tipo de uma das expressões na cláusula de junção está incorreto".
Badhon Jain
3
@ jain se seus tipos forem diferentes, a junção não funcionará. É provável que suas chaves sejam de tipos de dados diferentes. As duas chaves são int, por exemplo?
Yooakim
2
Qual é a solução Jain? Também estou enfrentando o mesmo erro e os tipos também são iguais no meu caso.
Sandeep
1
@Sandeep verifique suas chaves onde você se juntou a ela. Suponha que se esses são do tipo string e int, basta converter a chave da string em int.
Ankit 27/16
2
link atualizado: 101 Amostras LINQ - Junção externa esquerda
BukeMan 5/17
546

Se um provedor LINQ orientado a banco de dados for usado, uma junção externa esquerda significativamente mais legível pode ser gravada da seguinte forma:

from maintable in Repo.T_Whatever 
from xxx in Repo.T_ANY_TABLE.Where(join condition).DefaultIfEmpty()

Se você omitir DefaultIfEmpty(), terá uma junção interna.

Tome a resposta aceita:

  from c in categories
    join p in products on c equals p.Category into ps
    from p in ps.DefaultIfEmpty()

Essa sintaxe é muito confusa e não está claro como ela funciona quando você deseja sair da junção de tabelas MÚLTIPLAS.

Nota
Deve-se observar que from alias in Repo.whatever.Where(condition).DefaultIfEmpty()é o mesmo que uma aplicação externa / lateral esquerda da junção, que qualquer otimizador de banco de dados (decente) é perfeitamente capaz de converter em uma junção esquerda, desde que você não apresente por linha -valores (também conhecido como uma aplicação externa real). Não faça isso no Linq-2-Objects (porque não há otimizador de banco de dados ao usar o Linq-to-Objects).

Exemplo Detalhado

var query2 = (
    from users in Repo.T_User
    from mappings in Repo.T_User_Group
         .Where(mapping => mapping.USRGRP_USR == users.USR_ID)
         .DefaultIfEmpty() // <== makes join left join
    from groups in Repo.T_Group
         .Where(gruppe => gruppe.GRP_ID == mappings.USRGRP_GRP)
         .DefaultIfEmpty() // <== makes join left join

    // where users.USR_Name.Contains(keyword)
    // || mappings.USRGRP_USR.Equals(666)  
    // || mappings.USRGRP_USR == 666 
    // || groups.Name.Contains(keyword)

    select new
    {
         UserId = users.USR_ID
        ,UserName = users.USR_User
        ,UserGroupId = groups.ID
        ,GroupName = groups.Name
    }

);


var xy = (query2).ToList();

Quando usado com o LINQ 2 SQL, ele será traduzido de maneira adequada para a seguinte consulta SQL legível:

SELECT 
     users.USR_ID AS UserId 
    ,users.USR_User AS UserName 
    ,groups.ID AS UserGroupId 
    ,groups.Name AS GroupName 
FROM T_User AS users

LEFT JOIN T_User_Group AS mappings
   ON mappings.USRGRP_USR = users.USR_ID

LEFT JOIN T_Group AS groups
    ON groups.GRP_ID == mappings.USRGRP_GRP

Editar:

Consulte também " Converter consulta do SQL Server em consulta Linq " para obter um exemplo mais complexo.

Além disso, se você estiver fazendo isso no Linq-2-Objects (em vez do Linq-2-SQL), faça da maneira antiga (porque o LINQ to SQL converte isso corretamente para ingressar nas operações, mas sobre os objetos desse método força uma verificação completa e não tira proveito das pesquisas de índice, seja qual for ...):

    var query2 = (
    from users in Repo.T_Benutzer
    join mappings in Repo.T_Benutzer_Benutzergruppen on mappings.BEBG_BE equals users.BE_ID into tmpMapp
    join groups in Repo.T_Benutzergruppen on groups.ID equals mappings.BEBG_BG into tmpGroups
    from mappings in tmpMapp.DefaultIfEmpty()
    from groups in tmpGroups.DefaultIfEmpty()
    select new
    {
         UserId = users.BE_ID
        ,UserName = users.BE_User
        ,UserGroupId = mappings.BEBG_BG
        ,GroupName = groups.Name
    }

);
Stefan Steiger
fonte
21
Esta resposta é realmente útil. Obrigado por realmente oferecer uma sintaxe compreensível.
Chris Marisic
3
WTB uma consulta LINQ compatível com NHibernate ... :)
mxmissile
30
O LINQ to SQL converte isso corretamente para ingressar nas operações. Sobre objetos, no entanto, esse método força uma verificação completa. É por isso que a documentação oficial oferece a solução de junção de grupo que pode tirar proveito dos hashes para indexar pesquisas.
Tamir Daniely
3
Eu acho que a sintaxe explícita joiné muito mais legível e clara do que uma whereseguida porDefaultIfEmpty
FindOut_Quran
1
@ user3441905: Contanto que você apenas precise ingressar na tabela a com a tabela b, pode ser. Mas assim que você tiver mais do que isso, não será. Mas mesmo para apenas 2 tabelas, acho que é muito verboso. A opinião popular também parece ser contra você, pois essa resposta começou com 0 quando a resposta principal já tinha mais de 90 votos positivos.
23815 Stefan Steiger
132

Usando expressão lambda

db.Categories    
  .GroupJoin(db.Products,
      Category => Category.CategoryId,
      Product => Product.CategoryId,
      (x, y) => new { Category = x, Products = y })
  .SelectMany(
      xy => xy.Products.DefaultIfEmpty(),
      (x, y) => new { Category = x.Category, Product = y })
  .Select(s => new
  {
      CategoryName = s.Category.Name,     
      ProductName = s.Product.Name   
  });
N Rocking
fonte
8
O Join e o GroupJoin não oferecem suporte à junção esquerda. O truque com o uso de GroupJoin é que você pode ter grupos vazios e depois converter esses grupos vazios em valores vazios. DefaultIfEmpty simplesmente faz isso, o significado Enumerable.Empty<Product>.DefaultIfEmpty()retornará um IEnumerable com um único valor de default(Product).
Tamir Daniely
61
Tudo isso para realizar uma junção esquerda?
FindOut_Quran
7
Obrigado por isso! Não há muitos exemplos de expressões lambda por aí, isso funcionou para mim.
Johan Henkens
1
Obrigado pela resposta. Ele produziu a coisa mais próxima do SQL bruto LEFT OUTER JOIN que escrevi ao longo dos anos
John Gathogo
1
Realmente não precisa do último Select (), o objeto anon no SelectMany () pode ser refatorado para a mesma saída. Outro pensamento é testar y para null para simular uma equivalência LEFT JOIN mais próxima.
Denny Jacob
46

Agora como um método de extensão:

public static class LinqExt
{
    public static IEnumerable<TResult> LeftOuterJoin<TLeft, TRight, TKey, TResult>(this IEnumerable<TLeft> left, IEnumerable<TRight> right, Func<TLeft, TKey> leftKey, Func<TRight, TKey> rightKey,
        Func<TLeft, TRight, TResult> result)
    {
        return left.GroupJoin(right, leftKey, rightKey, (l, r) => new { l, r })
             .SelectMany(
                 o => o.r.DefaultIfEmpty(),
                 (l, r) => new { lft= l.l, rght = r })
             .Select(o => result.Invoke(o.lft, o.rght));
    }
}

Use como você normalmente usaria o join:

var contents = list.LeftOuterJoin(list2, 
             l => l.country, 
             r => r.name,
            (l, r) => new { count = l.Count(), l.country, l.reason, r.people })

Espero que isso poupe algum tempo.

Matas Vaitkevicius
fonte
44

Dê uma olhada neste exemplo . Esta consulta deve funcionar:

var leftFinal = from left in lefts
                join right in rights on left equals right.Left into leftRights
                from leftRight in leftRights.DefaultIfEmpty()
                select new { LeftId = left.Id, RightId = left.Key==leftRight.Key ? leftRight.Id : 0 };
Devart
fonte
3
Pode rser acessado na cláusula select após o uso de uma associação?
Farhad Alizadeh Noori
@FarhadAlizadehNoori Yes It can.
Po-ta-toe
O autor provavelmente pretendia reutilizar ra segunda fromcláusula. ie from r in lrs.DefaultIfEmpty()Caso contrário, esta consulta não faz muito sentido e, provavelmente, nem sequer compilar devido a restar fora de contexto para a seleção.
Saeb Amini
@ Devart, quando li a sua pergunta, me lembrou do filme Clockwisecom John Cleese, lol.
Matas Vaitkevicius 18/04/19
1
Da esquerda para a direita, para a esquerda, para a esquerda, para a esquerda, para a direita, para a esquerda, para a esquerda, para a direita ... Oh, caramba ... A sintaxe do uso de LEFT OUTER JOIN no LINQ realmente não é clara, mas esses nomes realmente a tornam ainda mais incerta.
Mike Gledhill
19

Uma implementação de junção externa esquerda por métodos de extensão pode parecer

public static IEnumerable<Result> LeftJoin<TOuter, TInner, TKey, Result>(
  this IEnumerable<TOuter> outer, IEnumerable<TInner> inner
  , Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector
  , Func<TOuter, TInner, Result> resultSelector, IEqualityComparer<TKey> comparer)
  {
    if (outer == null)
      throw new ArgumentException("outer");

    if (inner == null)
      throw new ArgumentException("inner");

    if (outerKeySelector == null)
      throw new ArgumentException("outerKeySelector");

    if (innerKeySelector == null)
      throw new ArgumentException("innerKeySelector");

    if (resultSelector == null)
      throw new ArgumentException("resultSelector");

    return LeftJoinImpl(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer ?? EqualityComparer<TKey>.Default);
  }

  static IEnumerable<Result> LeftJoinImpl<TOuter, TInner, TKey, Result>(
      IEnumerable<TOuter> outer, IEnumerable<TInner> inner
      , Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector
      , Func<TOuter, TInner, Result> resultSelector, IEqualityComparer<TKey> comparer)
  {
    var innerLookup = inner.ToLookup(innerKeySelector, comparer);

    foreach (var outerElment in outer)
    {
      var outerKey = outerKeySelector(outerElment);
      var innerElements = innerLookup[outerKey];

      if (innerElements.Any())
        foreach (var innerElement in innerElements)
          yield return resultSelector(outerElment, innerElement);
      else
        yield return resultSelector(outerElment, default(TInner));
     }
   }

O seletor de resultados precisa cuidar dos elementos nulos. Fx.

   static void Main(string[] args)
   {
     var inner = new[] { Tuple.Create(1, "1"), Tuple.Create(2, "2"), Tuple.Create(3, "3") };
     var outer = new[] { Tuple.Create(1, "11"), Tuple.Create(2, "22") };

     var res = outer.LeftJoin(inner, item => item.Item1, item => item.Item1, (it1, it2) =>
     new { Key = it1.Item1, V1 = it1.Item2, V2 = it2 != null ? it2.Item2 : default(string) });

     foreach (var item in res)
       Console.WriteLine(string.Format("{0}, {1}, {2}", item.Key, item.V1, item.V2));
   }
Bertrand
fonte
4
Essa é apenas uma opção para o LINQ to objects, no entanto, e não poderá converter a consulta para nenhum provedor de consultas, que é o caso de uso mais comum para esta operação.
Servy
13
Mas a pergunta foi "Como executar junção externa esquerda em C # LINQ para objetos ..."
Bertrand
12

dê uma olhada neste exemplo

class Person
{
    public int ID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Phone { get; set; }
}

class Pet
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}

public static void LeftOuterJoinExample()
{
    Person magnus = new Person {ID = 1, FirstName = "Magnus", LastName = "Hedlund"};
    Person terry = new Person {ID = 2, FirstName = "Terry", LastName = "Adams"};
    Person charlotte = new Person {ID = 3, FirstName = "Charlotte", LastName = "Weiss"};
    Person arlene = new Person {ID = 4, FirstName = "Arlene", LastName = "Huff"};

    Pet barley = new Pet {Name = "Barley", Owner = terry};
    Pet boots = new Pet {Name = "Boots", Owner = terry};
    Pet whiskers = new Pet {Name = "Whiskers", Owner = charlotte};
    Pet bluemoon = new Pet {Name = "Blue Moon", Owner = terry};
    Pet daisy = new Pet {Name = "Daisy", Owner = magnus};

    // Create two lists.
    List<Person> people = new List<Person> {magnus, terry, charlotte, arlene};
    List<Pet> pets = new List<Pet> {barley, boots, whiskers, bluemoon, daisy};

    var query = from person in people
        where person.ID == 4
        join pet in pets on person equals pet.Owner  into personpets
        from petOrNull in personpets.DefaultIfEmpty()
        select new { Person=person, Pet = petOrNull}; 



    foreach (var v in query )
    {
        Console.WriteLine("{0,-15}{1}", v.Person.FirstName + ":", (v.Pet == null ? "Does not Exist" : v.Pet.Name));
    }
}

// This code produces the following output:
//
// Magnus:        Daisy
// Terry:         Barley
// Terry:         Boots
// Terry:         Blue Moon
// Charlotte:     Whiskers
// Arlene:

agora você é capaz de, include elements from the leftmesmo se esse elemento has no matches in the right, no nosso caso, recuperamosArlene até ele não ter correspondência no certo

aqui está a referência

Como executar junções externas esquerdas (Guia de Programação em C #)

Basheer AL-MOMANI
fonte
a saída deve ser: Arlene: Não existe
user1169587
10

Esta é a forma geral (como já fornecido em outras respostas)

var c =
    from a in alpha
    join b in beta on b.field1 equals a.field1 into b_temp
    from b_value in b_temp.DefaultIfEmpty()
    select new { Alpha = a, Beta = b_value };

No entanto, aqui está uma explicação que espero esclarecer o que isso realmente significa!

join b in beta on b.field1 equals a.field1 into b_temp

essencialmente cria um conjunto de resultados separado b_temp que inclui efetivamente 'linhas' nulas para entradas no lado direito (entradas em 'b').

Então a próxima linha:

from b_value in b_temp.DefaultIfEmpty()

..itera sobre esse conjunto de resultados, definindo o valor nulo padrão da 'linha' no lado direito e definindo o resultado da junção da linha do lado direito para o valor de 'b_value' (ou seja, o valor à direita lado, se houver um registro correspondente, ou 'null', se não houver).

Agora, se o lado direito for o resultado de uma consulta LINQ separada, ela consistirá em tipos anônimos, que podem ser apenas 'algo' ou 'nulo'. Se, no entanto, for um enumerável (por exemplo, uma Lista - onde MyObjectB é uma classe com 2 campos), é possível ser específico sobre quais valores 'nulos' padrão são usados ​​para suas propriedades:

var c =
    from a in alpha
    join b in beta on b.field1 equals a.field1 into b_temp
    from b_value in b_temp.DefaultIfEmpty( new MyObjectB { Field1 = String.Empty, Field2 = (DateTime?) null })
    select new { Alpha = a, Beta_field1 = b_value.Field1, Beta_field2 = b_value.Field2 };

Isso garante que 'b' em si não seja nulo (mas suas propriedades podem ser nulas, usando os valores nulos padrão que você especificou) e permite verificar as propriedades de b_value sem obter uma exceção de referência nula para b_value. Observe que, para um DateTime anulável, um tipo de (DateTime?), Ou seja, 'DateTime anulável' deve ser especificado como o 'Tipo' do nulo na especificação do 'DefaultIfEmpty' (isso também se aplica a tipos que não são 'nativos'). 'anulável, por exemplo, duplo, flutuante).

Você pode executar várias junções externas esquerdas encadeando a sintaxe acima.

Chris Halcrow
fonte
1
de onde vem b_value?
Jack Fraser
9

Aqui está um exemplo se você precisar juntar mais de 2 tabelas:

from d in context.dc_tpatient_bookingd
join bookingm in context.dc_tpatient_bookingm 
     on d.bookingid equals bookingm.bookingid into bookingmGroup
from m in bookingmGroup.DefaultIfEmpty()
join patient in dc_tpatient
     on m.prid equals patient.prid into patientGroup
from p in patientGroup.DefaultIfEmpty()

Ref: https://stackoverflow.com/a/17142392/2343

Sameer Alibhai
fonte
4

Método de extensão que funciona como junção esquerda com sintaxe de junção

public static class LinQExtensions
{
    public static IEnumerable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(
        this IEnumerable<TOuter> outer, IEnumerable<TInner> inner, 
        Func<TOuter, TKey> outerKeySelector, 
        Func<TInner, TKey> innerKeySelector, 
        Func<TOuter, TInner, TResult> resultSelector)
    {
        return outer.GroupJoin(
            inner, 
            outerKeySelector, 
            innerKeySelector,
            (outerElement, innerElements) => resultSelector(outerElement, innerElements.FirstOrDefault()));
    }
}

acabou de escrever no núcleo do .NET e parece estar funcionando conforme o esperado.

Teste pequeno:

        var Ids = new List<int> { 1, 2, 3, 4};
        var items = new List<Tuple<int, string>>
        {
            new Tuple<int, string>(1,"a"),
            new Tuple<int, string>(2,"b"),
            new Tuple<int, string>(4,"d"),
            new Tuple<int, string>(5,"e"),
        };

        var result = Ids.LeftJoin(
            items,
            id => id,
            item => item.Item1,
            (id, item) => item ?? new Tuple<int, string>(id, "not found"));

        result.ToList()
        Count = 4
        [0]: {(1, a)}
        [1]: {(2, b)}
        [2]: {(3, not found)}
        [3]: {(4, d)}
Bezio
fonte
4

Aqui está uma versão bastante fácil de entender usando a sintaxe do método:

IEnumerable<JoinPair> outerLeft =
    lefts.SelectMany(l => 
        rights.Where(r => l.Key == r.Key)
              .DefaultIfEmpty(new Item())
              .Select(r => new JoinPair { LeftId = l.Id, RightId = r.Id }));
Tim Pohlmann
fonte
3

Existem três tabelas: pessoas, escolas e people_schools, que conectam pessoas às escolas em que estudam. Uma referência à pessoa com id = 6 está ausente na tabela person_schools. No entanto, a pessoa com id = 6 é apresentada na grade unida à esquerda do resultado.

List<Person> persons = new List<Person>
{
    new Person { id = 1, name = "Alex", phone = "4235234" },
    new Person { id = 2, name = "Bob", phone = "0014352" },
    new Person { id = 3, name = "Sam", phone = "1345" },
    new Person { id = 4, name = "Den", phone = "3453452" },
    new Person { id = 5, name = "Alen", phone = "0353012" },
    new Person { id = 6, name = "Simon", phone = "0353012" }
};

List<School> schools = new List<School>
{
    new School { id = 1, name = "Saint. John's school"},
    new School { id = 2, name = "Public School 200"},
    new School { id = 3, name = "Public School 203"}
};

List<PersonSchool> persons_schools = new List<PersonSchool>
{
    new PersonSchool{id_person = 1, id_school = 1},
    new PersonSchool{id_person = 2, id_school = 2},
    new PersonSchool{id_person = 3, id_school = 3},
    new PersonSchool{id_person = 4, id_school = 1},
    new PersonSchool{id_person = 5, id_school = 2}
    //a relation to the person with id=6 is absent
};

var query = from person in persons
            join person_school in persons_schools on person.id equals person_school.id_person
            into persons_schools_joined
            from person_school_joined in persons_schools_joined.DefaultIfEmpty()
            from school in schools.Where(var_school => person_school_joined == null ? false : var_school.id == person_school_joined.id_school).DefaultIfEmpty()
            select new { Person = person.name, School = school == null ? String.Empty : school.name };

foreach (var elem in query)
{
    System.Console.WriteLine("{0},{1}", elem.Person, elem.School);
}
Alex
fonte
Enquanto este é talvez a resposta da pergunta dar alguma explicação sobre sua resposta :)
Amir
2

Essa é uma sintaxe SQL comparada à sintaxe LINQ para junções externas internas e externas. Junção externa esquerda:

http://www.ozkary.com/2011/07/linq-to-entity-inner-and-left-joins.html

"O exemplo a seguir faz uma junção de grupo entre produto e categoria. Essa é essencialmente a junção esquerda. A expressão into retorna dados mesmo que a tabela de categorias esteja vazia. Para acessar as propriedades da tabela de categorias, agora precisamos selecionar o resultado enumerável adicionando o from cl na instrução catList.DefaultIfEmpty ().

ozkary
fonte
1

Executar junções externas esquerdas no linq C # // Executar junções externas esquerdas

class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

class Child
{
    public string Name { get; set; }
    public Person Owner { get; set; }
}
public class JoinTest
{
    public static void LeftOuterJoinExample()
    {
        Person magnus = new Person { FirstName = "Magnus", LastName = "Hedlund" };
        Person terry = new Person { FirstName = "Terry", LastName = "Adams" };
        Person charlotte = new Person { FirstName = "Charlotte", LastName = "Weiss" };
        Person arlene = new Person { FirstName = "Arlene", LastName = "Huff" };

        Child barley = new Child { Name = "Barley", Owner = terry };
        Child boots = new Child { Name = "Boots", Owner = terry };
        Child whiskers = new Child { Name = "Whiskers", Owner = charlotte };
        Child bluemoon = new Child { Name = "Blue Moon", Owner = terry };
        Child daisy = new Child { Name = "Daisy", Owner = magnus };

        // Create two lists.
        List<Person> people = new List<Person> { magnus, terry, charlotte, arlene };
        List<Child> childs = new List<Child> { barley, boots, whiskers, bluemoon, daisy };

        var query = from person in people
                    join child in childs
                    on person equals child.Owner into gj
                    from subpet in gj.DefaultIfEmpty()
                    select new
                    {
                        person.FirstName,
                        ChildName = subpet!=null? subpet.Name:"No Child"
                    };
                       // PetName = subpet?.Name ?? String.Empty };

        foreach (var v in query)
        {
            Console.WriteLine($"{v.FirstName + ":",-25}{v.ChildName}");
        }
    }

    // This code produces the following output:
    //
    // Magnus:        Daisy
    // Terry:         Barley
    // Terry:         Boots
    // Terry:         Blue Moon
    // Charlotte:     Whiskers
    // Arlene:        No Child

https://dotnetwithhamid.blogspot.in/

Hamid
fonte
1

Gostaria de acrescentar que, se você receber a extensão MoreLinq, agora há suporte para junções esquerdas homogêneas e heterogêneas agora

http://morelinq.github.io/2.8/ref/api/html/Overload_MoreLinq_MoreEnumerable_LeftJoin.htm

exemplo:

//Pretend a ClientCompany object and an Employee object both have a ClientCompanyID key on them

return DataContext.ClientCompany
    .LeftJoin(DataContext.Employees,                         //Table being joined
        company => company.ClientCompanyID,                  //First key
        employee => employee.ClientCompanyID,                //Second Key
        company => new {company, employee = (Employee)null}, //Result selector when there isn't a match
        (company, employee) => new { company, employee });   //Result selector when there is a match

EDITAR:

Em retrospecto, isso pode funcionar, mas converte o IQueryable em um IEnumerable, pois o morelinq não converte a consulta em SQL.

Em vez disso, você pode usar um GroupJoin como descrito aqui: https://stackoverflow.com/a/24273804/4251433

Isso garantirá que ele permaneça como um IQueryable, caso você precise executar mais operações lógicas posteriormente.

Reese De Wind
fonte
1

A maneira mais fácil é usar a palavra-chave Let. Isso funciona para mim.

from AItem in Db.A
Let BItem = Db.B.Where(x => x.id == AItem.id ).FirstOrDefault() 
Where SomeCondition
Select new YourViewModel
{
    X1 = AItem.a,
    X2 = AItem.b,
    X3 = BItem.c
}

Esta é uma simulação do Left Join. Se cada item na tabela B não corresponder ao item A, BItem retornará nulo

mahdi moghimi
fonte
0

Se você precisar ingressar e filtrar algo, isso pode ser feito fora da associação. O filtro pode ser feito após a criação da coleção.

Nesse caso, se eu fizer isso na condição de junção, reduzo as linhas retornadas.

A condição ternária é usada (= n == null ? "__" : n.MonDayNote,)

  • Se o objeto estiver null(portanto, sem correspondência), retorne o que está após o ?. __, nesse caso.

  • Else, devolver o que é após o :, n.MonDayNote.

Graças aos outros colaboradores, foi aí que comecei com meu próprio problema.


        var schedLocations = (from f in db.RAMS_REVENUE_LOCATIONS
              join n in db.RAMS_LOCATION_PLANNED_MANNING on f.revenueCenterID equals

                  n.revenueCenterID into lm

              from n in lm.DefaultIfEmpty()

              join r in db.RAMS_LOCATION_SCHED_NOTE on f.revenueCenterID equals r.revenueCenterID
              into locnotes

              from r in locnotes.DefaultIfEmpty()
              where f.LocID == nLocID && f.In_Use == true && f.revenueCenterID > 1000

              orderby f.Areano ascending, f.Locname ascending
              select new
              {
                  Facname = f.Locname,
                  f.Areano,
                  f.revenueCenterID,
                  f.Locabbrev,

                  //  MonNote = n == null ? "__" : n.MonDayNote,
                  MonNote = n == null ? "__" : n.MonDayNote,
                  TueNote = n == null ? "__" : n.TueDayNote,
                  WedNote = n == null ? "__" : n.WedDayNote,
                  ThuNote = n == null ? "__" : n.ThuDayNote,

                  FriNote = n == null ? "__" : n.FriDayNote,
                  SatNote = n == null ? "__" : n.SatDayNote,
                  SunNote = n == null ? "__" : n.SunDayNote,
                  MonEmpNbr = n == null ? 0 : n.MonEmpNbr,
                  TueEmpNbr = n == null ? 0 : n.TueEmpNbr,
                  WedEmpNbr = n == null ? 0 : n.WedEmpNbr,
                  ThuEmpNbr = n == null ? 0 : n.ThuEmpNbr,
                  FriEmpNbr = n == null ? 0 : n.FriEmpNbr,
                  SatEmpNbr = n == null ? 0 : n.SatEmpNbr,
                  SunEmpNbr = n == null ? 0 : n.SunEmpNbr,
                  SchedMondayDate = n == null ? dMon : n.MondaySchedDate,
                  LocNotes = r == null ? "Notes: N/A" : r.LocationNote

              }).ToList();
                Func<int, string> LambdaManning = (x) => { return x == 0 ? "" : "Manning:" + x.ToString(); };
        DataTable dt_ScheduleMaster = PsuedoSchedule.Tables["ScheduleMasterWithNotes"];
        var schedLocations2 = schedLocations.Where(x => x.SchedMondayDate == dMon);
BionicCyborg
fonte
0
class Program
{
    List<Employee> listOfEmp = new List<Employee>();
    List<Department> listOfDepart = new List<Department>();

    public Program()
    {
        listOfDepart = new List<Department>(){
            new Department { Id = 1, DeptName = "DEV" },
            new Department { Id = 2, DeptName = "QA" },
            new Department { Id = 3, DeptName = "BUILD" },
            new Department { Id = 4, DeptName = "SIT" }
        };


        listOfEmp = new List<Employee>(){
            new Employee { Empid = 1, Name = "Manikandan",DepartmentId=1 },
            new Employee { Empid = 2, Name = "Manoj" ,DepartmentId=1},
            new Employee { Empid = 3, Name = "Yokesh" ,DepartmentId=0},
            new Employee { Empid = 3, Name = "Purusotham",DepartmentId=0}
        };

    }
    static void Main(string[] args)
    {
        Program ob = new Program();
        ob.LeftJoin();
        Console.ReadLine();
    }

    private void LeftJoin()
    {
        listOfEmp.GroupJoin(listOfDepart.DefaultIfEmpty(), x => x.DepartmentId, y => y.Id, (x, y) => new { EmpId = x.Empid, EmpName = x.Name, Dpt = y.FirstOrDefault() != null ? y.FirstOrDefault().DeptName : null }).ToList().ForEach
            (z =>
            {
                Console.WriteLine("Empid:{0} EmpName:{1} Dept:{2}", z.EmpId, z.EmpName, z.Dpt);
            });
    }
}

class Employee
{
    public int Empid { get; set; }
    public string Name { get; set; }
    public int DepartmentId { get; set; }
}

class Department
{
    public int Id { get; set; }
    public string DeptName { get; set; }
}

RESULTADO

Manikandan Deivasigamani
fonte
0

De acordo com minha resposta a uma pergunta semelhante, aqui:

Junção externa esquerda de Linq para SQL usando sintaxe Lambda e junção em 2 colunas (chave de junção composta)

Obtenha o código aqui ou clone meu repositório no github e jogue!

Inquerir:

        var petOwners =
            from person in People
            join pet in Pets
            on new
            {
                person.Id,
                person.Age,
            }
            equals new
            {
                pet.Id,
                Age = pet.Age * 2, // owner is twice age of pet
            }
            into pets
            from pet in pets.DefaultIfEmpty()
            select new PetOwner
            {
                Person = person,
                Pet = pet,
            };

Lambda:

        var petOwners = People.GroupJoin(
            Pets,
            person => new { person.Id, person.Age },
            pet => new { pet.Id, Age = pet.Age * 2 },
            (person, pet) => new
            {
                Person = person,
                Pets = pet,
            }).SelectMany(
            pet => pet.Pets.DefaultIfEmpty(),
            (people, pet) => new
            {
                people.Person,
                Pet = pet,
            });
Adam Cox
fonte
0

Visão geral: neste trecho de código, demonstro como agrupar por ID onde a Tabela1 e a Tabela2 têm um relacionamento um para muitos. Eu agrupo em Id, Field1 e Field2. A subconsulta é útil, se uma terceira pesquisa de Tabela for necessária e ela exigiria um relacionamento de associação à esquerda. Eu mostro um agrupamento de junção esquerdo e uma subconsulta linq. Os resultados são equivalentes.

class MyView
{
public integer Id {get,set};
    public String Field1  {get;set;}
public String Field2 {get;set;}
    public String SubQueryName {get;set;}                           
}

IList<MyView> list = await (from ci in _dbContext.Table1
                                               join cii in _dbContext.Table2
                                                   on ci.Id equals cii.Id

                                               where ci.Field1 == criterion
                                               group new
                                               {
                                                   ci.Id
                                               } by new { ci.Id, cii.Field1, ci.Field2}

                                           into pg
                                               select new MyView
                                               {
                                                   Id = pg.Key.Id,
                                                   Field1 = pg.Key.Field1,
                                                   Field2 = pg.Key.Field2,
                                                   SubQueryName=
                                                   (from chv in _dbContext.Table3 where chv.Id==pg.Key.Id select chv.Field1).FirstOrDefault()
                                               }).ToListAsync<MyView>();


 Compared to using a Left Join and Group new

IList<MyView> list = await (from ci in _dbContext.Table1
                                               join cii in _dbContext.Table2
                                                   on ci.Id equals cii.Id

                       join chv in _dbContext.Table3
                                                  on cii.Id equals chv.Id into lf_chv
                                                from chv in lf_chv.DefaultIfEmpty()

                                               where ci.Field1 == criterion
                                               group new
                                               {
                                                   ci.Id
                                               } by new { ci.Id, cii.Field1, ci.Field2, chv.FieldValue}

                                           into pg
                                               select new MyView
                                               {
                                                   Id = pg.Key.Id,
                                                   Field1 = pg.Key.Field1,
                                                   Field2 = pg.Key.Field2,
                                                   SubQueryName=pg.Key.FieldValue
                                               }).ToListAsync<MyView>();
Leão dourado
fonte
-1
(from a in db.Assignments
     join b in db.Deliveryboys on a.AssignTo equals b.EmployeeId  

     //from d in eGroup.DefaultIfEmpty()
     join  c in  db.Deliveryboys on a.DeliverTo equals c.EmployeeId into eGroup2
     from e in eGroup2.DefaultIfEmpty()
     where (a.Collected == false)
     select new
     {
         OrderId = a.OrderId,
         DeliveryBoyID = a.AssignTo,
         AssignedBoyName = b.Name,
         Assigndate = a.Assigndate,
         Collected = a.Collected,
         CollectedDate = a.CollectedDate,
         CollectionBagNo = a.CollectionBagNo,
         DeliverTo = e == null ? "Null" : e.Name,
         DeliverDate = a.DeliverDate,
         DeliverBagNo = a.DeliverBagNo,
         Delivered = a.Delivered

     });
swain saktiprasad
fonte
-1

Solução simples para a junção externa esquerda :

var setA = context.SetA;
var setB = context.SetB.Select(st=>st.Id).Distinct().ToList();
var leftOuter  = setA.Where(stA=> !setB.Contains(stA.Id)); 

notas :

  • Para melhorar o desempenho, o SetB pode ser convertido em um dicionário (se isso for feito, é necessário alterar isso :! SetB.Contains (stA.Id) ) ou um HashSet
  • Quando há mais de um campo envolvido, isso pode ser alcançado usando operações Set e uma classe que implementa: IEqualityComparer
Enrique Ramos
fonte
Uma junção externa esquerda retornaria correspondência setAe setBna resposta.
NetMage