Gh0stman eXPerience

As expressoes Lambda ja existem desde o .NET 3.0 e foram, por assim dizer, aprimoradas com o .NET 3.5 usando o Linq.

Vamos a parte pratica da coisa, como diferenciar uma da outra com um simples Select.

Linq:

var C = from o in db.Orders where o.OrderID == 1 select new { o.OrderID };

Lambda:

var C = db.Orders.Where(o => o.OrderID == 1).Select(o => new { o.OrderID });

Como da pra notar a diferenca nao eh TAO grande para uma consulta simples. A desgraca comeca quando voce precisa fazer uma consulta um pouco mais elaborada:

Linq:

var orderDetails = from o in db.Orders
        where o.OrderID == orderID
        join s in db.Shippers on o.ShipVia equals s.ShipperID
        join od in db.OrderDetails on o.OrderID equals od.OrderID
        join p in db.Products on od.ProductID equals p.ProductID
        join supplier in db.Suppliers on p.SupplierID equals supplier.SupplierID
        let total = od.Quantity * od.UnitPrice
        select new OrderDescription {Product = p.ProductName, Quantity = od.Quantity, 
                     ShipperName = s.CompanyName, Total = total, UnitPrice=od.UnitPrice,
                     SupplierName = supplier.CompanyName};

Lambda:

var orderDetails = db.Orders.Where(order => order.OrderID == orderID).
        Join(db.Shippers, o => o.ShipVia, s => s.ShipperID, 
          (o, s) => new { o.OrderID, ShipCompanyName = s.CompanyName }).
        Join(db.OrderDetails, o => o.OrderID, od => od.OrderID, 
          (o, od) => new {o.ShipCompanyName, od.ProductID, od.Quantity, od.UnitPrice }).
        Join(db.Products, od => od.ProductID, p => p.ProductID, 
          (OrderDetails, p) => new { OrderDetails, p.ProductName, p.SupplierID }).
        Join(db.Suppliers, p => p.SupplierID, s => s.SupplierID, 
          (OrderData, s) => new { OrderData, SupplierName = s.CompanyName}).
        Select(o => new OrderDescription
        {
            Product = o.OrderData.ProductName,
            Quantity = o.OrderData.OrderDetails.Quantity,
            ShipperName = o.OrderData.OrderDetails.ShipCompanyName,
            Total = o.OrderData.OrderDetails.Quantity * o.OrderData.OrderDetails.UnitPrice,
            UnitPrice = o.OrderData.OrderDetails.UnitPrice,
            SupplierName = o.SupplierName
        });

Vale a pena usar o Lambda em questoes simples como uma verificacao de inclusao:

var C = db.Orders.Single(o => o.OrderID == 1);

Ou de uma alteracao:

Orders Alt = db.Orders.Single(o => o.OrderID == 1);

Alt.campo = novovalor;

Entao, o que voce prefere?

Quem afinal de contas eh o mais rapido na hora de fazer uma comparacao?

str=="" 

str.Equals("")

str==string.empty 

str.Equals(string.empty) 

string.Length==0 

Depois de muita busca no google e no google groups achei alguns artigos sobre o assunto.
Mas o melhor foi ter encontrado um chart com comparativos com as velocidades onde:

As string normal tem 10 caracteres e as long tem 100.

O que acontece eh que o uso de "" faz com que o framework crie um objeto para entao verificar se o mesmo esta vazio, o que interfere na performance. A melhor opcao eh o uso do str.Lenght == 0 como mostra o grafico. Claro que isso pode ser diferente nas proximas versoes do .NET mas de qualquer forma vale o conhecimento.

fontes: Brendan Tompkins [MVP] e Google Groups

Voce ja esta familiarizado com o conceito de enumeradores? Nao? E com o conceito type-safe?

Exemplos de type-safe com enumeradores:

string Nome = string.Empty;
System.Drawing.Color.Blue;

Mas como que eu crio enumeradores para comeco de conversa:

public enum Ativo
{
      Nao = 0,
      Sim = 1,
}

Agora vamos ao que interessa:

int Ativow = 1;
Ativo at = (Ativo)Enum.Parse(typeof(Ativo), Ativow.ToString(), true);

switch (at)
{
      case Ativo.Nao:
            return "inativo";
            break;
      case Ativo.Sim:
            return "ativo";
            break;
}

Navegando pelo digg vi esse site, o BuiltWith.

Que essencialmente eh um site que diz que plataforma os outros sites sao feitos. De util eu nao vi muita coisa.... serve mais para "matar a curiosidade". Alguns sites como o do google nao dao muita informacao, o que decepciona, mas valeu a intencao.

Aproposito, o builtwith.com eh desenvolvido usando tecnologia ASP.NET

Segue a solucao de um problema que tive a algum tempo atras, trabalhar com multiplos DataKeys dentro de um mesmo DataGrid.

C#
GridView.DataKeys[Index1].Values[Index2] 

VB.NET
GridView.DataKeys(Index1).Values(Index2) 

Esse novo sistema de blogs que axei na net vai ser muito util pra mim.

Axei esse cara, o BlogEngine.Net no novo site de OpenSource da Microsoft. Muito bom por sinal e totalmente user friendly (basta saber um poko de ingles).

Os posts antigos de programacao eu vow recolocar aqui. Pois tambem me interessam quando eskeco de alguma coisa.