Consumindo XML com LINQ

Aloha!

Mais uma coisa legal de fazer com LINQ: consumir XML! Abaixo um exemplo básico de um arquivo RSS:

<?xml version="1.0" encoding="utf-8" ?> 
<rss version="2.0">
 <channel>
  <title>Teste Nerd RSS</title> 
  <link>http://www.qx3.com.br</link> 
  <description>Teste RSS</description> 
  <ttl>5</ttl> 
  <item>
    <title>NERD S/A</title> 
    <link>http://nerd-rj.blogspot.com</link> 
  </item>
  <item>
    <title>Gusmão</title> 
    <link>http://www.microsoft.com</link> 
  </item>
  <item status="disabled">
    <title>Francke</title> 
    <link>http://xmasters.com</link> 
  </item>
 </channel>
</rss>

Para começar a brincadeira, vamos criar um repeater no aspx da seguinte forma:

<asp:Repeater ID="rptRSS" runat="server">
<HeaderTemplate>
  RSS Ativos:<br /><br />
</HeaderTemplate>          
<ItemTemplate>
  <asp:Label
       Text='<%# Eval("Nome") %>'
       runat="server" /> - 
  <asp:HyperLink
       Text='<%# Eval("Url") %>'
       NavigateUrl='<%# Eval("Url") %>'
       runat="server" />
  <hr style="width:75%;text-align:left" />
</ItemTemplate>
</asp:Repeater>

Agora, apenas para efeitos de teste, vamos colocar nosso código no Page_Load do cs mesmo:

public partial class ReadFeedRSS : System.Web.UI.Page
{
  protected void Page_Load(object sender, EventArgs e)
  {
    XDocument feedXML = XDocument.Load(@"C:\FeedRSS.xml");

    var feeds = from feed in feedXML.Descendants("item")
                where feed.Attribute("status") == null || 
                      feed.Attribute("status").Value != "disabled"
                select new {
                        Nome = feed.Element("title").Value,
                        Url = feed.Element("link").Value
                       };
        
        rptRSS.DataSource = feeds;
        rptRSS.DataBind();
  }
}

Se tudo correr bem, vc verá algo simples... Mas com imaginação e criatividade, pode-se tirar uma aplicação muito legal com esse recurso.

flws!

Gerando XML com LINQ

Continuando a série linq, a pedido do Francke, segue abaixo um exemplo de como gerar um arquivo xml através de linq e base de dados.

Supondo que você já saiba criar classes LINQ, é claro.

DataClassesDataContext db = new DataClassesDataContext();

XElement xmlDb = new XElement("Artistas",
                   from art in db.Artists
                   orderby art.ArtistName
                   select new XElement("Artista",
                             new XAttribute("ArtistaID", art.ArtistId),
                             new XElement("Nome", art.ArtistName)
                             )
                 );

xmlDb.Save(@"C:\artistas.xml");

Flws?!

LINQ: Where

Da série LINQ, vamos ver neste post o uso da cláusula WHERE em nossa consulta. Veja o trecho abaixo:

string[] digits = { "zero", "um", "dois", "tres", "quatro", "cinco", "seis", "sete", "oito", "nove", "dez" };
var shortDigits = digits.Where((digit, index) => digit.Length < index);

Response.Write("Short Digits: 

");

foreach (var d in shortDigits)
{
  Response.Write("The word " + d + " is shorter than its value.");
  Response.Write("
");
}

Simples né?! Para os mais atentos e interessados, podemos contar no C# 3.0 com essa fabulosa "=>" setinha! Notem que no trecho '(digit, index) => digit.Length < index)' estamos nada mais nada menos que retornando o resultado! A grosso modo, é uma forma fácil de fazer um return em um if, por exemplo.

LINQ: Distinct + Count

Continuando a série LINQ você verá abaixo a utilização de Distinct e Count.

int[] factorsOf300 = { 2, 2, 3, 5, 5 };
int uniqueFactors = factorsOf300.Distinct().Count();

Response.Write(uniqueFactors);

No post anterior utilizamos a forma "tradicional" de consulta, neste post estamos utilizando a facilidade que as tão faladas LAMBDA Expressions nos fornecem. Temo um array de inteiros na primeira linha. Na segunda linha vocÊ pode ver que o intellicense lista uma série de alternativas para tratarmos os dados.

Replique o código e comece a babar com o VS2008!!!

Exemplo básico de consulta com LINQ

Segue abaixo um exemplo muito básico de consulta.

int[] text1 = { 1, 2, 3, 4};

var data = from t in text1
           select t + 1;

Response.Write("Exemplo básico de select no LINQ: < br > ");

foreach (var x in data)
{
   Response.Write(x + "< br >");
}

   Response.Write("Com o LINQ, percorremos o array com os numeros 1,2,3 e 4 selecionamos e incrementamos cada um.");

Replique este trecho de código e veja como é fácil usar o LINQ! A instrução SQL é criada de forma "inversa" ao que estamos acostumados a fazer, mas é facil de entender..

IRPF 2008 no Linux

Graças a Deus o programa da receita tem uma versão for linux!!! =)

http://imasters.uol.com.br/artigo/8234/linux/sua_declaracao_de_imposto_de_renda_com_linux/

No link acima o colunista ensina a instalar. É necessário realizar algumas tarefinhas com o JVM mas aparentemente nada difícil.

Vou tentar instalar hoje no meu ubuntu, depois comento mais.

[]'s

C# 3.0 - Implicitly typed

Aloha!

Outro recurso bastante interessante e produtivo na versão 3.0 é a declaração de variáveis sem a necessidade declaração explícita de seu tipo. Agora com a palavra "var" - conhecida por quem trabalha com javascript - aparece justamente para executar esta função.

Antes era necessário declarar da seguinte forma:

int number = 10;
string myTitle = "Nerd, Linux, Ubuntu e Cia";

Agora fica mais simples:

var number = 10;
var myName = "Bruno";

A variável foi criada sem determinarmos seu tipo. Esse papel fica na responsabilidade do próprio compilador.

Flws?!!!

Inicializadores de Objetos - C# 3.0

Olá!

Esta semana ralei em um projeto que estava sendo desenvolvido em C# 3.0 + .net 3.5 + LINQ. O prazo era curto e tive que catar muita coisa na net pra aprender rápido, pois mal havia começado em .net com C# 2.0 e .Net 2.0!!!

Graças a Deus tá tudo dando certo até agora e achei algo interessante dentre muitas novidades no C# 3.0: Auto Implemented Properties. Quer ver um exemplo? Dá uma olhada....

Código em C# 2.0:

protected void Page_Load(object sender, EventArgs e)
{
    Computador computador = new Computador(10);
    computador.Marca = "Sony";
    computador.Modelo = "Vaio";
    Response.Write(computador
}

public class Computador
{
    public int codigo;
    public int Codigo
    {
       get { return codigo; }
       private set { codigo = value; }
    }
    public string marca;
    public string Marca
    {
       get { return marca; }
       set { marca = value; }
    }
    public string modelo;
    public string Modelo
    {
       get { return modelo; }
       set { modelo = value; }
    }
    public Computador(int iCod)
    {
       Codigo = iCod;
    }
    public override string ToString()
    {
       return Codigo + " < br > " + Marca + " < br > " + Modelo;
    }
}

O mesmo código em C# 3.0:

protected void Page_Load(object sender, EventArgs e)
{
    Computador computador = new Computador(10);
    computador.Marca = "Sony";
    computador.Modelo = "Vaio";
    Response.Write(computador
}

public class Computador
{
    public int Codigo { get; private set; }
    public string Marca { get; set; }
    public string Modelo { get; set; }
    public Computador(int iCod)
    {
       Codigo = iCod;
    }
    public override string ToString()
    {
       return Codigo + " < br > " + Marca + " < br > " + Modelo;
    }
}

Legal né? Economizamos em linhas de código + organização + beleza!!!

Flws!!!