none
lambda expression join 3 tabelas RRS feed

  • Pergunta

  • Bom dia, estou tendo difculdade em fazer um join com 3 tabelas , fiz de varias maneiras mas o erro ainda persiste:

    Obrigado.

         public EstoqueMod DetalheEstoque(Int64 codigo)
            {
                try
                {
                    using (var bd = new bdEntities())
                    {

                        return bd.ENTRADAPRODUTO.Join(bd.PRODUTO,
                            e => e.CODIGO_PRODUTO,
                            p => p.CODIGO,
                            (e, p) => new { e, p })
                            .Join(bd.PRODUTOCLIENTE,
                                ep => ep.e.CODIGO_PRODUTO,
                                pc => pc.CODIGO_PRODUTO,
                                (ep, pc) => new
                                {
                                    ep.e.CODIGO,
                                    ep.p.CODIGO_GRUPO,
                                    ep.p.DS_PRODUTO,
                                    ep.p.DS_PONTO,
                                    ep.e.CODIGO_PRODUTO,
                                    ep.e.DS_DATA_ENTRADA,
                                    ep.e.DS_DATA_VENCIMENTO,
                                    ep.e.DS_QTDE_ESTOQUE,
                                    ep.e.DS_QTDE_MINIMA

                                })
                               .Select(
                                dados => new EstoqueMod()
                                {
                                    Codigo = dados.CODIGO,
                                    CodigoProduto = dados.CODIGO_PRODUTO,
                                    Produto = dados.DS_PRODUTO,
                                    Ponto = dados.DS_PONTO,
                                    DataEntrada = dados.DS_DATA_ENTRADA,
                                    DataVencimento = dados.DS_DATA_VENCIMENTO,
                                    Qtde = dados.DS_QTDE_ESTOQUE,
                                    EstoqueMinimo = dados.DS_QTDE_MINIMA,

                                }

                            ).Single(x => x.Codigo == codigo);


                    }

                }
                catch (Exception)
                {

                    throw new Exception("Erro ao detalhar estoque!");
                }

            }

    quinta-feira, 25 de junho de 2015 13:50

Respostas

  • Olá seria algo assim :

     return bd.ENTRADAPRODUTO.Join
                            (bd.PRODUTO,
                                e => e.CODIGO_PRODUTO,
                                p => p.CODIGO,
                                (e, p) => new { e, p })
                            .Join(bd.PRODUTOCLIENTE,
                                p => p.p.CODIGO,
                                e => e.CODIGO_PRODUTO,
                                (p, e) => new { p, e })
                            .Where(x => x.p.e.CODIGO == 3)
                            .GroupBy(x => x.p.e.Codigo)
                            .Select(x => x.First())
                            .ToList()
                            .Select(x => new EstoqueMod()
                                   {
                                    //seus campos
                                    }
                            .ToList();

    sexta-feira, 26 de junho de 2015 13:20

Todas as Respostas

  • Olá, poderia dizer qual erro está ocorrendo?

    Se está caindo na exceção, poste aqui a mensagem original do erro.


    Joel Rodrigues MSP, MCP, MTA Editor geral .NET Magazine E Easy .NET Magazine

    quinta-feira, 25 de junho de 2015 14:20
  • Olá,

     a estrutura seria assim :

    var join = db.T1
                                   .Join(db.T2,
                                         t1 => t1.ID,
                                         t2 => t2.ID_T2,
                                         (t1, t2) => new { t1, t2 })
                                   .Join(db.T3,
                                         t1 => t1.t2.ID_T2,
                                         t3 => t3.ID,
                                         (t1, t3) => new { t1, t3 })
                                   .Where(i => i.t3.ID > 0)
                                   .Select(i => i.t3)
                                   .ToList();
     Tente entender a estrutura que vai ficar facil.

    quinta-feira, 25 de junho de 2015 15:02
  • Olá amigo, na verdade não posso retornar um list e sim apenas um registro entao fiz dessa forma:

           return bd.ENTRADAPRODUTO.Join
                            (bd.PRODUTO,
                                e => e.CODIGO_PRODUTO,
                                p => p.CODIGO,
                                (e, p) => new
                                {e, p}).Join(bd.PRODUTOCLIENTE,
                                    p => p.e.CODIGO_PRODUTO,
                                    pc => pc.CODIGO_PRODUTO,
                                    (p, pc) => new {p, pc})
                            .Select(
                                dados => new EstoqueMod()
                                {
                                    Codigo = dados.p.e.CODIGO,
                                    CodigoProduto = dados.p.e.CODIGO_PRODUTO,
                                    Produto = dados.p.p.DS_PRODUTO,
                                    Ponto = dados.p.p.DS_PONTO,
                                    DataEntrada = dados.p.e.DS_DATA_ENTRADA,
                                    DataVencimento = dados.p.e.DS_DATA_VENCIMENTO,
                                    Qtde = dados.p.e.DS_QTDE_ESTOQUE,
                                    EstoqueMinimo = dados.p.e.DS_QTDE_MINIMA,

                                }

                            ).FirstOrDefault(x => x.Codigo == codigo);  (OK FUNCIONOU)

    --------------  E  forma abaixo tambem funciou: -------------------

         return bd.ENTRADAPRODUTO.Join(bd.PRODUTO,
                            e => e.CODIGO_PRODUTO,
                            p => p.CODIGO,
                            (e, p) => new { e, p })
                            .Join(bd.PRODUTOCLIENTE,
                                ep => ep.e.CODIGO_PRODUTO,
                                pc => pc.CODIGO_PRODUTO,
                                (ep, pc) => new
                                {
                                    ep.e.CODIGO,
                                    ep.p.CODIGO_GRUPO,
                                    ep.p.DS_PRODUTO,
                                    ep.p.DS_PONTO,
                                    ep.e.CODIGO_PRODUTO,
                                    ep.e.DS_DATA_ENTRADA,
                                    ep.e.DS_DATA_VENCIMENTO,
                                    ep.e.DS_QTDE_ESTOQUE,
                                    ep.e.DS_QTDE_MINIMA

                                })
                               .Select(
                                dados => new EstoqueMod()
                                {
                                    Codigo = dados.CODIGO,
                                    CodigoProduto = dados.CODIGO_PRODUTO,
                                    Produto = dados.DS_PRODUTO,
                                    Ponto = dados.DS_PONTO,
                                    DataEntrada = dados.DS_DATA_ENTRADA,
                                    DataVencimento = dados.DS_DATA_VENCIMENTO,
                                    Qtde = dados.DS_QTDE_ESTOQUE,
                                    EstoqueMinimo = dados.DS_QTDE_MINIMA,

                                }

                           ).FirstOrDefault(x => x.Codigo == codigo);  (OK FUNCIONOU)

    Agora minha dúvida é: Qual a maneira mais inteligente ?

    Obrigado.

    quinta-feira, 25 de junho de 2015 16:43
  • Bom,

     o que você faz nesse caso é buscar todos os itens e filtrar na memória, o ideal seria filtrar o codigo com um Where diretamente na consulta algo assim :

    return bd.ENTRADAPRODUTO.Join
                            (bd.PRODUTO,
                                e => e.CODIGO_PRODUTO,
                                p => p.CODIGO,
                                (e, p) => new
                                {e, p}).Join(bd.PRODUTOCLIENTE,
                                    p => p.e.CODIGO_PRODUTO,
                                    pc => pc.CODIGO_PRODUTO,
                                    (p, pc) => new {p, pc})
                           .Where(i => i.pc.Codigo == Codigo)
                           .Select(i => new ....
                           .FirstOrDefault();
     Veja que atribui o where, dessa maneira ele vai ser aplicado diretamente no sql gerado e não na memória. Essa seria a maneira ideal... 

    quinta-feira, 25 de junho de 2015 16:52
  • Blz vou ver aqui.

    Muito obrigado.

    quinta-feira, 25 de junho de 2015 16:53
  • Olá amigo,quando eu preciso de um registro funciona perfeito.

    Mas quando dou um "List()" os dados sao duplicados.

                        

     return bd.ENTRADAPRODUTO.Join
                              (bd.PRODUTO,
                                  e => e.CODIGO_PRODUTO,
                                  p => p.CODIGO,
                                  (e, p) => new { e, p })
                              .Join(bd.PRODUTOCLIENTE,
                                  p => p.e.CODIGO_PRODUTO,
                                  pc => pc.CODIGO_PRODUTO,
                                  (p, pc) => new { p, pc })
                              .Where(x => x.p.e.CODIGO== 3)
                              .Select(
                                  dados => new EstoqueMod()
                                  {
                                      Codigo = dados.p.e.CODIGO,
                                      CodigoProduto = dados.p.e.CODIGO_PRODUTO,
                                      Produto = dados.p.p.DS_PRODUTO,
                                      Ponto = dados.p.p.DS_PONTO,
                                      DataEntrada = dados.p.e.DS_DATA_ENTRADA,
                                      DataVencimento = dados.p.e.DS_DATA_VENCIMENTO,
                                      Qtde = dados.p.e.DS_QTDE_ESTOQUE,
                                      EstoqueMinimo = dados.p.e.DS_QTDE_MINIMA,
                                      PrecoVenda = dados.p.e.DS_VALOR_VENDA,
                                      PrecoUnitario = dados.pc.DS_VALOR_UNITARIO

                                  }

                              ).ToList();

    Obrigado.

    

    quinta-feira, 25 de junho de 2015 18:54
  • Sim você deve agrupar, seria algo mais ou menos assim :

    var join = bd.ENTRADAPRODUTO.Join
                              (bd.PRODUTO,
                                  e => e.CODIGO_PRODUTO,
                                  p => p.CODIGO,
                                  (e, p) => new { e, p })
                              .Join(bd.PRODUTOCLIENTE,
                                  p => p.e.CODIGO_PRODUTO,
                                  pc => pc.CODIGO_PRODUTO,
                                  (p, pc) => new { p, pc })
                              .Where(x => x.p.e.CODIGO== 3)
                              .GroupBy(i => i.p.e.Codigo)                          
                              .Select(i => i.First())                              
                              .ToList();
    
    //agora sua variavel join nao contera itens repetidos
    //pode atribuir os valores
    

     Basta agrupar e depois sua variavel "join" estará com os dados pode fazer nela esse select "EstoqueMod".

    Existem outras maneiras mas para entendimento acredito que seja a mais simples.

    quinta-feira, 25 de junho de 2015 19:48
  • Olá Daniel, está dificil, rrssr

    Ainda não foi,fiz dessa forma mas nao tive sucesso, então estou fuçando vamos ver se chego la.

      return bd.ENTRADAPRODUTO.Join
                            (bd.PRODUTO,
                                e => e.CODIGO_PRODUTO,
                                p => p.CODIGO,
                                (e, p) => new { e, p })
                            .Join(bd.PRODUTOCLIENTE,
                                p => p.p.CODIGO,
                                e => e.CODIGO_PRODUTO,
                                (p, e) => new { p, e })
                            .Where(x => x.p.e.CODIGO == 3)
                            .GroupBy(
                                dados => new EstoqueMod()
                                {
                                    Codigo = dados.p.e.CODIGO,
                                    CodigoProduto = dados.p.e.CODIGO_PRODUTO,
                                    Produto = dados.p.p.DS_PRODUTO,
                                    Ponto = dados.p.p.DS_PONTO,
                                    DataEntrada = dados.p.e.DS_DATA_ENTRADA,
                                    DataVencimento = dados.p.e.DS_DATA_VENCIMENTO,
                                    Qtde = dados.p.e.DS_QTDE_ESTOQUE,
                                    EstoqueMinimo = dados.p.e.DS_QTDE_MINIMA,
                                    PrecoVenda = dados.p.e.DS_VALOR_VENDA,
                                    PrecoUnitario = dados.e.DS_VALOR_UNITARIO

                                }
                            )
                            .Select(
                                dados => new EstoqueMod()
                                {
                                    Codigo = dados.Key.Codigo,
                                    CodigoProduto = dados.Key.CodigoProduto,
                                    Produto = dados.Key.Produto,
                                    Ponto = dados.Key.Ponto,
                                    DataEntrada = dados.Key.DataEntrada,
                                    DataVencimento = dados.Key.DataVencimento,
                                    Qtde = dados.Key.Qtde,
                                    EstoqueMinimo = dados.Key.EstoqueMinimo,
                                    PrecoVenda = dados.Key.PrecoVenda,
                                    PrecoUnitario = dados.Key.PrecoUnitario

                                }

                            ).ToList();

                        }

    Obrigadão.

    quinta-feira, 25 de junho de 2015 20:24
  • Olá Daniel, está dificil, rrssr

    Ainda não foi,fiz dessa forma mas nao tive sucesso, então estou fuçando vamos ver se chego la.

      return bd.ENTRADAPRODUTO.Join
                            (bd.PRODUTO,
                                e => e.CODIGO_PRODUTO,
                                p => p.CODIGO,
                                (e, p) => new { e, p })
                            .Join(bd.PRODUTOCLIENTE,
                                p => p.p.CODIGO,
                                e => e.CODIGO_PRODUTO,
                                (p, e) => new { p, e })
                            .Where(x => x.p.e.CODIGO == 3)
                            .GroupBy(
                                dados => new EstoqueMod()
                                {
                                    Codigo = dados.p.e.CODIGO,
                                    CodigoProduto = dados.p.e.CODIGO_PRODUTO,
                                    Produto = dados.p.p.DS_PRODUTO,
                                    Ponto = dados.p.p.DS_PONTO,
                                    DataEntrada = dados.p.e.DS_DATA_ENTRADA,
                                    DataVencimento = dados.p.e.DS_DATA_VENCIMENTO,
                                    Qtde = dados.p.e.DS_QTDE_ESTOQUE,
                                    EstoqueMinimo = dados.p.e.DS_QTDE_MINIMA,
                                    PrecoVenda = dados.p.e.DS_VALOR_VENDA,
                                    PrecoUnitario = dados.e.DS_VALOR_UNITARIO

                                }
                            )
                            .Select(
                                dados => new EstoqueMod()
                                {
                                    Codigo = dados.Key.Codigo,
                                    CodigoProduto = dados.Key.CodigoProduto,
                                    Produto = dados.Key.Produto,
                                    Ponto = dados.Key.Ponto,
                                    DataEntrada = dados.Key.DataEntrada,
                                    DataVencimento = dados.Key.DataVencimento,
                                    Qtde = dados.Key.Qtde,
                                    EstoqueMinimo = dados.Key.EstoqueMinimo,
                                    PrecoVenda = dados.Key.PrecoVenda,
                                    PrecoUnitario = dados.Key.PrecoUnitario

                                }

                            ).ToList();

                        }

    Obrigadão.


    sexta-feira, 26 de junho de 2015 11:49
  • Olá seria algo assim :

     return bd.ENTRADAPRODUTO.Join
                            (bd.PRODUTO,
                                e => e.CODIGO_PRODUTO,
                                p => p.CODIGO,
                                (e, p) => new { e, p })
                            .Join(bd.PRODUTOCLIENTE,
                                p => p.p.CODIGO,
                                e => e.CODIGO_PRODUTO,
                                (p, e) => new { p, e })
                            .Where(x => x.p.e.CODIGO == 3)
                            .GroupBy(x => x.p.e.Codigo)
                            .Select(x => x.First())
                            .ToList()
                            .Select(x => new EstoqueMod()
                                   {
                                    //seus campos
                                    }
                            .ToList();

    sexta-feira, 26 de junho de 2015 13:20
  • vou tentar rssrr.

    Nossa nunca apanhei tanto pra fazer um join kkkk

    sexta-feira, 26 de junho de 2015 13:29
  • Olá Daniel aparentemente funcionou, só tive que mudar o "first" para "firstorDefault"

    return bd.ENTRADAPRODUTO.Join
                            (bd.PRODUTO,
                                e => e.CODIGO_PRODUTO,
                                p => p.CODIGO,
                                (e, p) => new { e, p })
                            .Join(bd.PRODUTOCLIENTE,
                                p => p.p.CODIGO,
                                e => e.CODIGO_PRODUTO,
                                (p, e) => new { p, e })
                            .Where(x => x.p.e.CODIGO == 3)
                            .GroupBy(x => x.p.e.Codigo)
                            .Select(x => x.FirstOrDefault())
                            .ToList()
                            .Select(x => new EstoqueMod()
                                   {
                                    //seus campos
                                    }
                            .ToList();

    Muito obrigado mesmo.


    sexta-feira, 26 de junho de 2015 14:31