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? 