LINQ To XML

by Fabiano 15. maio 2008 01:07

 

Olá pessoal como tinha dito vamos fazer uma serie de artigos falando de LINQ, mês passado falei sobre sua teoria geral e nos aprofundamos mais no LINQ To SQL, este mês vamos falar mais sobre o LINQ To XML que uma ferramenta muito útil para trabalhar com XML, pra que já manipulou XML seja no Asp 3.0, ou ate mesmo nas versões anteriores do .NET  vai notar o quando esta ferramenta facilita nossa vida.

O LINQ TO XML

O LINQ to XML é um provedor de dados LINQ que é implementado no namespace System.Xml.LINQ a partir da versão 3.5 da plataforma .NET. Ele fornece um modelo de programação que permite ler, construir e escrever dados XML. Você pode usar LINQ To XML para realizar consultas LINQ sobre dados no formato XML que podem ser retornados do arquivo de sistemas, de uma URL HTTP remota, de um web service ou partir de qualquer XML em memória existente.

O LINQ To XML fornece mais recursos e facilidades para tratar com XML do que a API presente no namespace System.XML(XmlReader/XmlWriter) da versão anterior da plataforma .NET, sendo também mais eficiente, por usar menos memória, que a API DOM do XmlDocument fornece.

O conceito de documento XML é fundamental no DOM e os nós XML são criados no contexto do documento XML, se você desejar usar um elemento através de múltiplos documentos vai precisar importar os nós através do documento. O LINQ To XML simplifica essa abordagem.

No LINQ to XML você pode criar elementos XML diretamente: Ex:
XElement documentoXml = new XElement("Clientes"); 

Criando documentos XML

Para criar um arquivo XML vamos utilizar a classe XElement .Todos os atributos e elementos serão criados com os métodos SetAttributeValue e SetElementValue, para salvar o arquivo a classe disponibiliza o método Save.

Conforme o código abaixo adicione o método CriaXML

private void CriaXML()

    {

 

        XElement xml = new XElement("Clientes",

                    new XElement("Cliente",

                        new XAttribute("CliID", "1"),

                        new XElement("Nome", "Fabiano Belmonte"),

                        new XElement("Email", "fbelmonte@etniax.com.br")

                    ),

                    new XElement("Cliente",

                        new XAttribute("CliID", "2"),

                        new XElement("Nome", "Juca das Neves"),

                        new XElement("Email", "juca@bol.com.br")

                    )

                );

 

        xml.Save("c:\\xmlClientes.xml");

    }

Veja o Resultado:

<?xml version="1.0" encoding="utf-8"?>

<Clientes>

  <Cliente CliID="1">

    <Nome>Fabiano Belmonte</Nome>

    <Email>fbelmonte@etniax.com.br</Email>

  </Cliente>

  <Cliente CliID="2">

    <Nome>Juca das Neves</Nome>

    <Email>juca@bol.com.br</Email>

  </Cliente>

</Clientes>

 

Como e simples criar um arquivo XML e salva-lo no disco, note que não precisamos de nenhum outro namespace fizemos tudo pelo System.Xml.LINQ

Carregar arquivo XML

Para carregar e selecionar valores utilizando Linq to XML podemos utilizar a classe XElement. Método Load: carregar conteúdo XML de um arquivo ou da memórias, em uma de suas sobrecargas podemos passar o caminho do arquivo XML , as outras sobrecargas recebe como parâmetros um objeto TextReader ou XmlReader.Você também pode definir opções à partir do enum LoadOptions.

O LoadOption possui quatro opções . None : todas as linhas desnecessárias,linhas em branco e linhas de informações, do arquivo XML não serão carregadas. PreserveWhitespace: essa opção define que todas as linhas em branco do arquivo XML serão preservadas. SetBaseUri : essa opção define o preenchimento da propriedade BaseUri. SetLineInfo: essa opção habilita o preenchimento da das informações de linha, essa informações pode ser recuperadas através da interface IXmlLineInfo.

Conforme código abaixo adicione o método CarregaXml

private void CarregaXml()

    {

        XElement xml = XElement.Load("c:\\xmlClientes.xml", LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);

 

        //Mostra o caminho base.  

        Response.Write("Caminho :" + xml.BaseUri);

 

        //Mostra informações de linha   

        IXmlLineInfo lineInfo = xml as IXmlLineInfo;

        Response.Write(" <br> LineNumber " + lineInfo.LineNumber + "e LinePosition: " + lineInfo.LinePosition);

 

        //Carrega todos os elementos dentro do elemento root  

        IEnumerable<XElement> enumerable = xml.Elements();

 

        //Mostra todos os elementos dentro do elemento root  

        Response.Write("<br> Mostra todos os elementos dentro do elemento root <br>");

        foreach (var item in enumerable)

            Response.Write(item + "<br>");

 

        //Mostra todos os atributos nome do elento Cliente

        Response.Write("<br> Mostra todos os atributos nome do elento Cliente <br>");

        foreach (var item in enumerable.Attributes("CliID"))

            Response.Write(item + "<br>");

 

        //Mostra todos os elementos CPF dentro do elemento Cliente  

        Response.Write(" <br> Mostra todos os elementos Email dentro do elemento Cliente <br> ");

        foreach (var item in enumerable.Elements("Email"))

            Response.Write(item + "<br>");

    }

Alterando valores

Para isso utilizamos todo o poder do Linq para selecionar o atributo ou elemento que desejamos alterar.

Conforme o código abaixo adicione o método AlterandoValores

private void AlterandoValores()

    {

        XElement xml = XElement.Load("c:\\xmlClientes.xml", LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);

        IEnumerable<XElement> elements = xml.Elements();

 

       

        foreach (var item in elements.Elements("Nome").Where(e => e.Value == "Fabiano Belmonte"))

            item.Value = "Adriano Jose";

 

 

        foreach (var item in elements.Attributes("CliID").Where(e => e.Value == "1"))

            item.Value = "12";

 

        //Salva Alterações  

        xml.Save("c:\\xmlClientes.xml");

    }

Excluindo Valores

Agora vamos excluir um elemento de dentro de um XML, utilizaremos o mesmo conceito onde retiramos um elemento que possua o atributo passado veja como e simples.

 

Conforme o código abaixo adicione o método ExcluindoValores

private void ExcluindoValores()

    {

        XElement xml = XElement.Load("c:\\xmlClientes.xml", LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);

        IEnumerable<XElement> elements = xml.Elements();

 

        elements.AncestorsAndSelf("Cliente").Where(e => e.Attribute("CliID").Value == "2").Remove();

 

        //Salva Alterações  

        xml.Save("c:\\xmlClientes.xml");

    }

Inserindo Elementos

Para inserir elementos em um XML, também e muito simples precisamos primeiramente fazer o load no XML, em seguida criar um novo elemento e adicionar no XML Conforme o código abaixo adicione o método InsereElemento

private void InsereElemento()

    {

 

        XElement xml = XElement.Load("c:\\xmlClientes.xml", LoadOptions.SetBaseUri | LoadOptions.SetLineInfo);

 

        XElement Newxml = new XElement(

                          new XElement("Cliente",

                              new XAttribute("CliID", "2"),

                              new XElement("Nome", "Juca das Neves"),

                              new XElement("Email", "juca@bol.com.br")

                          )

                      );

 

        xml.Add(Newxml);

 

        xml.Save("c:\\xmlClientes.xml");

 

    }

 

E isso pessoal com estes exemplos realizamos quase todas operações básicas com o LINQ.XML, com isso conseguimos ter uma idéia de o quanto e simples e fácil trabalhar com este novo elemento da FrameWork 3.5.

Espero ter ajudado.

Bons Códigos...

 

 

Tags:

Delegates

by Fabiano 19. abril 2008 00:25

Olá pessoal,  em nossas aulas sempre damos dicas para nossos alunos, seja mostrando boas praticas ou novidades ou até mesmo funcionalidades mais antigas, mais que facilitam e deixam o nosso codigo sempre mais inteligente e intuitivo. Eu estava falando sobre delegates, foi na aula em que falava de Querys LINQ utilizando Lambda Expression,  e percebi que muitos alunos não conheciam muito sobre delegates e por isso tambem não utilizavam em seus projetos. Por isso resolvi falar um pouco mais sobre o assunto aqui em nosso BLOG. 

Os delegates estão presentes no .NET desde sua versão beta. Qual sua função? E permitir que utilizemos metodos de uma outra classe em nosso contexto atual, da mesma maneira que existe os ponteiros para objetos em C++  o delegate pode ser utilizado como referência para uma ou mais funções em C# e ser invocado quando necessário. 

Quando criamos um delegate precisamos de um nome e da declaração dos parametros necessários de entrada ou de saida. Os delegates não são construções simples como struct etc, são uma classe, pois qualquer delegate declarado é herdado da classe base System.Delegate do .NET 

Na verdade um delegate pode ser herdado de duas classes distintas System.Delegate ou System.MulticastDelegate, se o delegate tiver um tipo de retorno “void” ele é automaticamente um System.MulticastDelegate, assim ele suporta inúmeras funções com um operador “+=”.Se o delegate tiver um tipo de retorno não “void” ele é um System.Delegate e não suporta multiplos métodos como o caso anterior. 

Falando em termos menos tecnicos, quando você declara uma variável do tipo do delegate, essa varíavel vai receber (quando for instanciada) um endereço de uma função, que deve ter a mesma assinatura do delegate. É uma especie de ponteiro. 

Mãos a obra: 

Como Criamos um Delegate: 

Podemos criar delegates de duas formas como dito acima, com retorno ou sem retorno. Vejamos: 

public delegate int valor(int VL1, int VL2);
e
delegate void PopulaResultado(int Vl1, int Vl2);

Podemos utilizar um exemplo bem simples para demostrar sua utilização.

class Exemplo
{

        static void Main(string[] args)
        {
            Exemplo prog = new Exemplo();
            MeuMetodoDelegate MeuEx1 = new MeuMetodoDelegate(prog.ePossitivo);
            MeuMetodoDelegate MeuEx2 = new MeuMetodoDelegate(ePossitivoSimbolo);
            Console.WriteLine("{0} is {1}; use the sign \"{2}\".", 5, MeuEx1(5), MeuEx2(5));
            Console.WriteLine("{0} is {1}; use the sign \"{2}\".", -3, MeuEx1(-3), MeuEx2(-3));
            Console.WriteLine("{0} is {1}; use the sign \"{2}\".", 0, MeuEx1(0), MeuEx2(0));
         }

        public delegate String MeuMetodoDelegate(int myInt);

        public String ePossitivo(int myInt)
        {
            if (myInt > 0)
                return ("Sim");
            if (myInt < 0)
                return ("Não");
            return ("Zerado");
        }

        public static String ePossitivoSimbolo(int myInt)
        {
            if (myInt > 0)
                return ("+");
            if (myInt < 0)
                return ("-");
            return ("");
        }
    }
  

Observer que criamos um unico delegate MeuMetodoDelegate que recebe um inteiro como parametro e retorna uma String para chamarmos um precisamos da estância da classe e para chamarmos o método statico não precisamos da estância. Podemos ainda fazer chamadas assíncronas de metedos utilizando o delegate para isso temos que criar o delegate com a mesma assinatura de uma método de fazer a chamada via BeginInvoke. Vejamos um exemplo: Lembrando que neste caso o método não precisa ser statico

MeuMetodoDelegate MeuEx2 = new MeuMetodoDelegate(this.ePossitivoSimbolo);
MeuEx2.BeginInvoke(3, null, null); 

Desta maneira você poderá fazer chamadas assíncronas dos seus metodos dentro de sua aplicação, mais um beneficio da utilização de delegates em sua aplicação. Estes é so um pequeno exemplo de como os delegates podem ser uteis em seu dia a dia.

Bons Códigos...

Tags:

.Net

Boa prática de AJAX

by Fabiano 9. abril 2008 00:22

 

 

O Microsoft AJAX Framework oferece muitos, muitos, muitos e muitos recursos interessantes. Porém é necessário tomar alguns cuidados para evitar a má utilização destes recursos em funcionalidades desnecessárias.

Um exemplo simples: um formulário com 1 botão e label e quando clicamos no botão, alteramos a propriedade texto do label para DateTime.Now.ToStiong() e com isso exibimos a hora atual.

Procedimento padrão de ajax: colocar um Script Manager e um UpdatePanel… arrasta os controles para o UpdatePanel e pronto!!!! AJAX implementado… 

Claro que isso é o suficiente para dar a impressão que estamos melhorando muito a performance de nossa página, porém podemos melhorar muito mais.

O botão está dentro do Update Panel de forma desnecessária, isso porque ele simplesmente faz o evento click para alterar o valor do Label, ou seja, somente o Label precisa ser enviado para o servidor.

Solução:

  • Tirar o botão do Update Panel
  • Adicionar uma trigger para o botão dentro do Update Panel 

Veja o código:

<asp:UpdatePanel ID="UpdatePanel1" runat="server">
        <Triggers>
            <asp:AsyncPostBackTrigger ControlID="Button1" />
        </Triggers>
        <ContentTemplate>
            <asp:Label ID="Label1" runat="server" Text="Label"></asp:Label>
    <asp:Button ID="Button1" runat="server" onclick="Button1_Click" Text="Button" />
           
        </ContentTemplate>
    </asp:UpdatePanel>

Com isso diminuímos o tráfego de dados entre applicação e servidor! em um cenário maior, isso pode mudar muito a performance de sua aplicação.

Conclusão: não utilize o Update Panel em toda a página, é preferível colocar mais do que um Update Panel na página do que colocar em lugares desnecessários. 

 

 

Bons Códigos...

 

Tags: , ,

.Net

LINQ - Language Integrated Query

by Fabiano 22. março 2008 21:40

Olá pessoal vou começar uma serie de artigos falando do LINQ. Mas antes de começarmos a trabalhar diretamente com ele, gostaria de falar um pouco sobre sua teoria e explicar melhor seu conceito para que possamos explorar o máximo de seus recursos.
Primeiro vou falar sobre a ferramenta, em seguida vamos percorrer quase todas suas funcionalidades. Acredito que isso levara uma serie de artigos espero que vocês gostem e passem a aproveitar o máximo desta ferramenta que tanto tem a nos oferecer. Vamos La...

Definição:

Segundo a definição da Microsoft Linq é um conjunto de extensões do .Net Framework, bem como das novas linguagens (VB9 e C#) que provêem novas capacidades dentro de um ambiente de programação, executar queries em dados armazenados na memória ou em um repositório de dados externo, como um SGBD ou arquivo XML.

Transformando em uma linguagem mais prática, é uma tecnologia que nos permite abstrair a sintaxe SQL (no caso de pesquisa em BD) e ao mesmo tempo unificar a sintaxe de pesquisas nos mais diversos meios de armazenamento de informações como: Arrays, XML, etc. 

A Microsoft então diferenciou o LINQ de acordo com o tipo de dado onde ele vai realizar a pesquisa, daí surgiram os nomes: 

Neste primeiro artigo vou explorar o LINQ  to SQL e nos próximos vamos falando de suas outras extensões.

 

LINQ to SQL:

É uma implementação específica do LINQ para o SQL Server que converte consultas escritas em C# ou Visual Basic em SQL dinâmico, provendo uma interface que permite mapear os objetos do banco de dados gerando as classes para realizar as operações usando a sintaxe LINQ; 

Também permite realizar alterações nos objetos e atualizar o banco de dados. 

Inicialmente o LINQ To SQL só funciona com Banco de Dados SQL Server devido ao padrão adotado pela Microsoft  "ANSI“

Se todos os fabricantes de Banco de Dados adotassem este mesmo padrão então o LINQ funcionaria para todos os Bancos de Dados, mas a equipe do projeto LINQ esta trabalhando para que outros fornecedores de banco de dados façam a implementação para seus produtos. Vamos aguardar...

O/R Mapping 

O modelo de mapeamento objeto relacional para banco de dados SQLServer, consiste no mapeamento das:

Tabelas do banco de dados como classes;

Campos como propriedades; 

Procedures e funções como métodos;

Desta forma você tem no designer de classe da aplicação um conjunto de classes que representam visão 1:1 do seu banco de dados.

 

Note que a representação de classes é a mesma que a do banco de dados, até mesmo suas chaves primárias e relacionamentos. Esse passa a ser nosso modelo de entidades, e também o Objeto de Acesso ao Banco de Dados.

Ele mantém toda esta estrutura para utilizar da melhor forma possível na hora de montar a string SQL.

Entendendo o objeto DataContext:

Após você arrastar suas tabelas e procedures para dentro do diagrama como no exemplo acima, ao clicar no salvar o Visual Studio ira gerar classes que representam as entidades e relacionamentos que temos de dados modelado. Para cada diagrama LINQ SQL e adicionado à nossa solução, uma classe DataContext. Esta classe é o principal canal pelo qual nós teremos acesso a entidades de pesquisa do banco de dados, bem como inserções as alterações. A classe criada DataContext terá propriedades que representam cada um quadro dentro de nós modelado o banco de dados, bem como métodos para cada procedimento armazenado é acrescentado.

Por exemplo, abaixo está a classe DataClassesDataContext que é baseado no modelo que criamos acima:


 

Note que temos a classe Customer com todas as colunas da tabela agora como Propriedade da classe, e isso para todas as outras tabelas adicionadas no diagrama.

Gostaria de deixar claro que tudo que e gerado automaticamente pelo LINQ e feito de uma maneira muito mais clara e limpa que por exemplo os DataSets Tipados, agora conseguimos ter o controle total do que esta sendo gerado, pois como mostrei acima conseguimos ver as classes geradas ter acesso ao código e ate mesmo criar tudo isso na mão, gosto de ressaltar isso porque traz mais confiança no processo, pois muitas pessoas criticavam muito a MS pelos códigos gerados dinamicamente de baixa qualidade com o LINQ isso e muito diferente.

E o que e mais legal e a economia de tempo acompanhada com a qualidade de arquitetura que ganhamos utilizando os diagramas LINQ, pois quantos projetos foram gerados sem terem ao menos um único diagrama de classe, agora você será obrigado a ter pelo menos um, mas isso e um outro assunto... Não quero começar a falar de arquitetura neste artigo mais podemos falar disso no futuro, de como ficaria uma arquitetura de aplicação com LINQ.

Agora que já vimos as facilidades e vantagens de definição de projeto, vamos colocar a mão na massa.

 

Criando Querys:

Agora que já temos nosso diagrama criado vamos escrever facilmente algumas Querys muito utilizadas em nosso dia a dia, onde poderemos ter idéia da potencia e facilidade agregada a rotinas de acesso a dados.

O código a seguir usa sintaxe LINQ query para obter uma seqüência de Produto. Observe como o código está pesquisando em todos os Produto/Categoria fazendo um JOIN para obter apenas os produtos da categoria “Confections”:

DataClassesDataContext Db = new DataClassesDataContext();

var ProdutosConf = from p in Db.Products

                   where p.Category.CategoryName == "Confections"

                   select p;

O código abaixo demonstra como recuperar um único produto a partir do banco de dados, atualizar o seu preço e, em seguida, salvar as alterações de volta no banco de dados

DataClassesDataContext Db = new DataClassesDataContext();

Product produtoDb = Db.Products.Single(p => p.ProductID == 54);

produtoDb.UnitPrice = 25;
produtoDb.UnitsInStock = 4;

Db.SubmitChanges();

O código abaixo demonstra como inserir um novo produto na tabela.

DataClassesDataContext Db = new DataClassesDataContext();
Product produtoDbNew = new Product();

produtoDbNew.ProductName = "The Club";
produtoDbNew.SupplierID = 1;
produtoDbNew.CategoryID = 2;
produtoDbNew.QuantityPerUnit = "35 pages";
produtoDbNew.UnitPrice = 99;
produtoDbNew.UnitsInStock = 150;
produtoDbNew.UnitsOnOrder = 15;
produtoDbNew.ReorderLevel = 50;
produtoDbNew.Discontinued = false;

Db.Products.InsertOnSubmit(produtoDbNew);

Db.SubmitChanges();

Agora vamos deleterar um produto.

DataClassesDataContext Db = new DataClassesDataContext();
Product produtoDbRemove = Db.Products.Single(p => p.ProductID == 54);

Db.Products.DeleteOnSubmit(produtoDbRemove);

Podemos tambem deletar varios produtos de uma so vez, como no exemplo abaixo onde faço um select de todos os produtos que tenhão “HOT” em seu nome e mando deletar todos eles.
PS: o Contains utilizado na query abaico corresponde ao LIKE %% do SQL.

var produtos = from p in Db.Products
             where p.ProductName.Contains("Hot")
             select p;

Db.Products.DeleteAllOnSubmit(produtos);

Agora vamos fazer a chamada da storeprocedure adicionada em nosso diagrama, lembrando que quando adicionamos  procedures elas se tornam métodos e sua chamada fica bem simples de implementar como no exemplo abaixo onde chamo a proc “CustOrdersOrders” que passado um Id de cliente ela retorna todas as ordens do cliente.

DataClassesDataContext Db = new DataClassesDataContext();

var resultadodaconsulta = Db.CustOrdersOrders("BONAP");

O que e bem legal e que os parametros da procedure passam a ser parametros da assinatura do metodo criado pelo Visual Studio e quer mais uma coisa muito legal após obtermos o resultado podemos ter acesso direto no intelisence aos campos de retorno da procedure como na imagem abaixo.

Isso e muito legal, veja o compilador foi la na procedure viu os campos de retorno e já disponibilizou aqui para que possamos utilizar sem nem sequer sabermos quais campos tinhas para retorno dentro da procedure.

Espero que tenham gostado tanto do artigo como do LINQ, nos próximos artigos continuarei falando de LINQ talvez explore um pouco mais o SQL mais falaremos bastante de LINQ  ainda.

Bons Códigos...


 

Tags: , , ,

.Net

LINQ to Objects

by Fabiano 20. março 2008 21:31

 

Acredito que com essa ferramenta (LINQ) a Microsoft conseguiu chegar muito mais perto de seu objetivo, de conseguir dar mais produtividade para o desenvolvimento ela vem tentando isso desde o VB 6, e nas primeiras versões da FrameWork .NET já tínhamos os DataSets tipados e outros approaches que eu não gosto muito, pela sua falta de transparência mais com o LINQ acredito que eles acertaram em cheio, pois ele bem utilizado melhora de mais a velocidade do desenvolvimento e uma característica muito interessante sobre ele é a legibilidade e facilidade de aprendizado que ele traz para o projeto como um todo, pois ele na sua base e simples de entender e um projeto todo baseado em LINQ fica mais simples. E não pensem quem terão códigos de baixa qualidade não porque e mais uma qualidade, códigos limpos e performáticos. Agora vamos falar de LINQ  To Objects.

LINQ to Objects

O termos LINQ to Objects se refere ao uso de queries LINQ em IEnumerable ou IEnumerable<T> que são o resultado de uma consulta LINQ em um XML ou SQL, e com isso você pode fazer consultas LINQ no resultado de suas consultas, mas com a utilização do NameSpace "System.Linq"  você poderá fazer consultas em qualquer de enumerable seja List<T>, Array, Dictionary<TKey, TValue> seja ela uma coleção que você definiu ou um retorno de uma consulta ao banco de dados por exemplo.

Basicamente o LINQ to Objects representa uma nova abordagem dobre como recuperar dados de uma coleção de objetos, pois sem ele teríamos sempre que fazer complexos foreach loops para poder especificar como queria o resultado de coleções, para poder formatar do jeito que correto seu retorno, com o LINQ to Objects você passa a escrever de forma declarativa o que deve se obter.

Alem disso as Queries LINQ oferecem três principais vantagens em relação às tradicionais foreach loops:

1.       Elas são mais concisas e legíveis, especialmente quando são muitas condições de filtragem.

2.       Elas fornecem poderosa filtragem, ordenação e agrupamento de capacidades com um mínimo de aplicação código.

3.       Eles podem ser levados para outras fontes de dados com pouca ou nenhuma modificação.

Em geral, quanto mais complexa a operação que deseja realizar sobre os dados, mais a vantagem que você vai perceber usando LINQ em vez das tradicionais técnicas de interação e isso vale para todas as abordagens do LINQ seja To SQL, XML ou Objects.

 

Agora vamos fazer uma serie de exemplos de como se utilizar o LINQ to Objects para obter melhores resultados em suas aplicações.

 

Criando queries LINQ em ArrayList:

using System;

using System.Collections;

using System.Linq;

 

namespace GenericLINQ

{

    public class Student

    {

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public int[] Scores { get; set; }

    }

 

    class Program

    {

        static void Main(string[] args)

        {

            ArrayList arrList = new ArrayList();

            arrList.Add(

                new Student

                    {

                        FirstName = "Svetlana", LastName = "Omelchenko", Scores = new int[] { 98, 92, 81, 60 }

                    });

            arrList.Add(

                new Student

                    {

                        FirstName = "Claire", LastName = "O’Donnell", Scores = new int[] { 75, 84, 91, 39 }

                    });

            arrList.Add(

                new Student

                    {

                        FirstName = "Sven", LastName = "Mortensen", Scores = new int[] { 88, 94, 65, 91 }

                    });

            arrList.Add(

                new Student

                    {

                        FirstName = "Cesar", LastName = "Garcia", Scores = new int[] { 97, 89, 85, 82 }

                    });

 

            var query = from Student student in arrList

                        where student.Scores[0] > 95

                        select student;

 

            foreach (Student s in query)

                Console.WriteLine(s.LastName + ": " + s.Scores[0]);

 

            // Keep the console window open in debug mode.

            Console.WriteLine("Pressione qualquer tecla para sair.");

            Console.ReadKey();

        }

    }

}

 

/* Output: 
    Omelchenko: 98
    Garcia: 97
*/

 

 

Agora vamos fazer um exemplo em que criamos duas classes uma de Pessoa e a outra de Filho.

E com essas duas classes vamos fazer vários selects...


using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

 

namespace ExemplosLinqtoObjects

{

 

    class Programw

    {

        static void Main2(string[] args)

        {

 

            //Alimentado lista de pessoas

            var pessoas = new List<Pessoa>

            {

                new Pessoa {Nome="Alexandre" , Idade=19}

                , new Pessoa {Nome="Mario" , Idade=20}

                , new Pessoa {Nome="Joao", Idade=25}

                , new Pessoa {Nome="Pedro", Idade=25}

            };

 

            var query = from p in pessoas

                        select p;

 

            foreach (var p in query)

            {

                Console.WriteLine("Nome: " + p.Nome);

            }

 

 

            var query2 = from p in pessoas

                         where p.Idade >= 20

                         select p;

 

            foreach (var p in query2)

            {

                Console.WriteLine("Nome: " + p.Nome);

            }

 

 

            var query3 = from p in pessoas

                         orderby p.Idade descending

                         group p by p.Idade into g

                         select new { idade = g.Key, total = g };

 

            foreach (var grupo in query3)

            {

                Console.WriteLine("Pessoas com:" + grupo.idade + " anos");

                foreach (var pessoa in grupo.total)

                {

                    Console.WriteLine(pessoa.Nome);

                }

            }

 

 

            var filhos = new List<Filho>

            {

                new Filho {Nome = "Alexandre Jr", nomePai="Alexandre"}

                , new Filho {Nome = "Alexandre Jr 2", nomePai="Alexandre"}

                , new Filho {Nome = "Joao Jr", nomePai="Joao"}

            };

 

            var query4 = from p in pessoas

                         join f in filhos

                         on p.Nome equals f.nomePai

                         select new { Pai = p.Nome, Filho = f.Nome };

 

            foreach (var i in query4)

            {

                Console.WriteLine("Pai: " + i.Pai + " Filho:" + i.Filho);

            }

 

 

            var query5 = from p in pessoas

                         join f in filhos

                         on p.Nome equals f.nomePai

                         group f by f.nomePai into g

                         select new { Pai = g.Key, Total = g };

 

            foreach (var i in query5)

            {

                foreach (var grupo in i.Total)

                {

                    Console.WriteLine(grupo.Nome);

 

                }

            }

 

            Console.Read();

 

        }

    }

 

    class Pessoa

    {

        public string Nome { get; set; }

        public int Idade { get; set; }

    }

 

    class Filho

    {

        public string Nome { get; set; }

        public string nomePai { get; set; }

    }

}

  

Note que a partir de uma lista de objetos conseguimos implementar uma serie de queries que com certeza vão facilitar em muito nossa vida. Tivemos muitos exemplos e com esse artigo fechamos a serie sobre LINQ espero ter conseguido passar todo o valor que esta ferramenta pode agregar ao nosso dia a dia...

 

Espero ter ajudado.

Bons Códigos...

 

Tags:

.Net

Como Utilizar Left Join em Consultas LINQ to SQL

by Fabiano 18. março 2008 21:28

 

Ultimamente tenho recebido nos treinamentos varios alunos tem me perguntado se e possivel fazer LEFT JOIN em consultas LINQ estão resolvi escrever este pequeno artigo com um exemplo de como fazer.  Espero poder abrir um caminho que os levara a consultas LINQ cada vez mais otmizadas e inteligente.

Vamos ao exemplo:

Para isso vou utilizar as tabelas de Customers e de Orders ( Clientes e Pedidos)  no Banco de Dados Northwind, adcionei um novo Cliente sem nenhum pedido, vou criar um SELECT com LEFT JOIN que me retorne todos os clientes que o nome comece com a letra(“F”)  mesmo que eles não tenham registros na tabela de pedido.

NorthwindDataContext db= new NorthwindDataContext();

        var query=  from c in db.Customers

                    where c.CustomerID.StartsWith("F")

                    join o in db.Orders on c.CustomerID equals o.CustomerID into sr

                    from x in sr.DefaultIfEmpty()

                    select new {CustomerID= c.CustomerID, ContactName=c.ContactName, OrderID = x.OrderID == null ? -1 : x.OrderID};   

Veja que eu usei o operador join into na Query o que resultou em um LEFT JOIN, Eu adcionei meu filtro no final da clausula WHERE, e retornei um tipo anonimo que contem  CustomerID, ContactName, e OrderID onde -1 corresponde os clientes que não tem nenhum pedido e os que tem pedido retornamos o ID do pedido.

Veja a string SQL correspondente:

SELECT [t0].[CustomerID], [t0].[ContactName], 

    (CASE 

        WHEN [t1].[OrderID] IS NULL THEN @p1

        ELSE [t1].[OrderID]

     END) AS [value]

FROM [dbo].[Customers] AS [t0]

LEFT JOIN [dbo].[Orders] AS [t1] ON [t0].[CustomerID] = [t1].[CustomerID]

WHERE [t0].[CustomerID] LIKE @p0

Observe como o LEFT JOIN aparece, perceba como o case reflete IF/ELSE que eu adicionei na Query acima.

Bons Códigos...

 

Tags: , ,

.Net

Post Inaugural...

by Fabiano 18. janeiro 2008 20:42

Fala Galera! estou inaugurando hoje o meu Blog!
Ultimamente tenho passado à escrever bastante e resolvi seguir o conselho do meu ilustre e querido amigo Kung-Fu Panda (Vulgo Facunte), amigo este que sempre me incentivou e me ajudou muito em minha caminhada e crescimento profissional! Valeu Pan!  serei sempre grato.
Ainda na seção de agradecimentos não posso deixar de falar de minha querida e amada esposa! Marcela você é sempre uma fonte de inspiração e tranquilidade, sou grato a DEUS todos os dias por ter vc ao meu lado! Obrigado por sua força e incentivo sempre.
Bom sem mais delongas!!! Pretento postar pelo menos uma vez por semana algum artigo, meu objetivo é falar sobre Tecnologias .NET, Arquitetura de Software, sobre Metodologia de Dev e também sobre Padrões de Projetos. Espero que meu número de Post cresça sempre, e que possa sempre contribuir para o seu crescimento, seja ele pessoal ou profissional.
 
 
Bem Vindo!
 
Bons Códigos Sempre...
Fabiano Belmonte

Tags:

Diversos

Powered by BlogEngine.NET 1.5.0.7
Theme by Mads Kristensen