Lambda.Where(l=>l.StartsWith(“III”));

Último post da serie sobre lambda, caso você não acompanhou os outros post acesse agora mesmo os post I, II.
Muitas vezes precisamos fazer junções de dados e assim como SQL , LINQ nos permite fazer junções de dados, sobre um ou mais campos chaves.
O exemplo a seguir mostra como exibir as cidades de um determinado estado, antes de criamos o método que fara a junção dos dados precisamos criar duas class “Estado ” e “Cidade”.

 public class Estado
    {
        public int codigo { get; set; }
        public string nome { get; set; }
        public string sigla { get; set; }

        public List ListaEstado()
        {
            List t = new List()
            {
                new Estado { codigo = 1, nome = "Acre", sigla = "AC" }
            };

            List estados = new List()
            {
                 new Estado { codigo = 1, nome = "Acre", sigla = "AC" },
                 new Estado { codigo = 2, nome = "Alagoas", sigla = "AL" },
                 new Estado { codigo = 3, nome = "Amapá", sigla = "AP" },
                 new Estado { codigo = 4, nome = "Amazonas", sigla = "AM" },
                 new Estado { codigo = 5, nome = "Bahia", sigla = "BA" },
                 new Estado { codigo = 6, nome = "Ceará", sigla = "CE" },
                 new Estado { codigo = 7, nome = "Distrito Federal", sigla = "DF" },
                 new Estado { codigo = 8, nome = "São Paulo", sigla = "SP" },
           };

            return estados.OrderBy(l => l.nome).ToList();
        }
    }
 public class Cidade
    {
        public int codigo { get; set; }
        public int codigoEstado { get; set; }
        public string nome { get; set; }

        public List ListaCidade()
        {
            List cidade = new List()
            {
                 new Cidade { codigo = 1, codigoEstado = 1, nome = "Acrelandia" },
                 new Cidade { codigo = 2, codigoEstado = 2, nome = "Agua Branca" },
                 new Cidade { codigo = 3, codigoEstado = 3, nome = "Amapa" },
                 new Cidade { codigo = 4, codigoEstado = 4, nome = "Manaus" },
                 new Cidade { codigo = 5, codigoEstado = 5, nome = "Abaira" },
                 new Cidade { codigo = 6, codigoEstado = 6, nome = "Acarau" },
                 new Cidade { codigo = 7, codigoEstado = 7, nome = "Brazlândia" },
                 new Cidade { codigo = 8, codigoEstado = 8, nome = "Barueri" },
                 new Cidade { codigo = 9, codigoEstado = 8, nome = "São Paulo" },
                 new Cidade { codigo = 10, codigoEstado = 8, nome = "Presidente Prudente" }
            };

            return cidade.OrderBy(l => l.nome).ToList();
        }
    }

Abaixo temos o método responsável para fazer a junção entre os dados.

 public List CidadePorEstado(string uf )
        {
            var query = (from estado in new Estado().ListaEstado()
                         join cidade in new Cidade().ListaCidade() on estado.codigo equals cidade.codigoEstado
                         where (estado.sigla.Contains(uf) || uf == null)
                         orderby estado.nome
                         select new Cidade
                         {
                             codigo = cidade.codigo,
                             codigoEstado = cidade.codigoEstado,
                             nome = cidade.nome,
                         }).ToList();

            return query;
        }

Executando o método:

     ExemploLINQ linq = new ExemploLINQ();
     linq.CidadePorEstado("SP");

Resultado da Operação:
codigo:8,codigoEstado:8,nome:Barueri,
codigo:10,codigoEstado:8,nome:Presidente Prudente,
codigo:9,codigoEstado:8,nome:São Paulo

Entendendo o Método:

Na linha from estado in new Estado().ListaEstado() , estamos falando para a LINQ que a variável estado estará recebendo os valores que estão dentro do método ListaEstado .

Uma vez a referência feita, conseguimos acessar as propriedades do método ListaEstado.

“estado.nome,estado.codigoEstado,estado.sigla”.

Na linha   join cidade in new Cidade().ListaCidade() on estado.codigo equals cidade.codigoEstado.

Etamos carregando a variável cidade como no exemplo anterior porém estamos utilizando o operador  JOIN , uma vez a variável cidade carregada com os valores,  podemos fazer a junção de dados onde a variável  estado.codigo for igual a cidade.codigoEstado

Na linha where (estado.sigla.Contains(uf) || uf == null), estamos fazendo a comparação onde a variável estado.sigla  contém  o parâmetro uf ou a variável uf for igual a  nula .

Caso a variável uf for nula o método listara  as cidades de todos os estados.
 
Nessa trilogia básica sobre Lambda e consultas LINQ, mostrei como podemos utilizar essa poderosa ferramenta para aumentar nossa produtividade,abaixo estou disponibilizando alguns link interessante sobre o assunto.

http://msdn.microsoft.com/pt-br/library/vstudio/bb397933.aspx
http://msdn.microsoft.com/pt-br/library/vstudio/bb397687.aspx
http://code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b

Link do projeto:Projeto Lambda

LEAVE A COMMENT