Charla: Creando La Capa de Acceso a Datos con LINQ

Hola a todos.

El pasado miércoles 30 de abril tuve la oportunidad de compartir con la Comunidad de Desarrolladores .NET de Guatemala la charla Creando La Capa de Acceso a Datos con LINQ.

Fue una actividad muy bonita, la asistencia estuvo fenomenal y ahora quiero compartir con todos ustedes los documentos que conforman la presentación:

Creando La Capa de Acceso a Datos con LINQ.pdf
LINQ_DEMOS.zip

Acá pueden ver algunas fotos del evento.

Espero que estos recursos sean de utilidad para ustedes y espero sus comentarios y sugerencias.

Saludos.

José

Rolando Guay Paz

Technorati Tags: LINQ,Visual Studio 2008

SQL Server 2008: Aplicaciones de Misión Crítica

Hola a todos.

El pasado 4 de marzo tuve la oportunidad de presentar una conferencia durante el evento de lanzamiento de los nuevos productos 2008 de Microsoft acerca de Aplicaciones de Misión Crítica en SQL Server 2008. 

Las personas encargadas de manejar IT se encuentran todos los días con muchos desafíos, en particular podemos mencionar:

• Administrar IT y los crecientes requerimientos regulatorios
• Cumplir con  los SLAs de disponibilidad del sistema
• Asegurar el desempeño mientras la carga aumenta

Estos, así como otros desafíos deben poder enfrentarse de manera directa, eficiente y a bajo costo. Es allí donde entra SQL Server 2008 para poder enfrentar estos desafíos.  Ahora SQL Server ya no solo es un simple repositorio de datos que tiene interfaces gráficas bonitas y fáciles de usar, va mucho más allá. Bajo el principio de “Sus datos en cualquier lugar, en cualquier momento”, SQL Server 2008 provee de mecanismos para entregar datos a cualquier plataforma, sea empresarial o de hogar, en cualquier dispositivo, como teléfonos celulares, pda’s o la Internet, provee de más servicios como Reportes, Sincronización, Búsqueda, Query, Análisis, Integración, etc. Se integra con la mayoría de productos como Biztalk Server, Visual Studio 2008, Office y .net Framework, además de soportar no solo un modelo OLTP, sino OLAP, FILESYSTEM y XML.

SQL Server 2008: Nuevas Facilidades Para Desarrolladores

Hola a todos.

El día 12 de marzo (se cambió la fecha) tuve la oportunidad de compartir con los miembros de la Comunidad de Desarrolladores .NET de Guatemala una charla sobre SQL Server 2008 y las nuevas facilidades (como le llamo yo) que trae incorporadas para nosotros los desarrolladores.

Channel 9

¿Conoces Channel 9?

Es un portal creado y soportado por Microsoft para desarrolladores donde puedes encontrar muchos recursos sobre las tecnologías que se están desarrollando actualmente, así como las tendencias y las cosas que están por venir.

Desafortunadamente no está en español pero puedes eso no debe impedir que le eches un vistazo de cuando en cuando y veas las posibilidades y todo lo que allí se puede aprender.

Disfrútalo.

Ejecución Diferida en LINQ

La ejecución diferida de LINQ es uno de los conceptos más importantes y menos entendidos de esta tecnología. Es bastante importante que los desarrolladores comprendan este concepto si quieren llegar a explotar al máximo el potencial de LINQ.

Nota: En varias partes de este artículo sobre ejecución diferida, me referiré a una estructura de datos llamada árbol de expresión. Para entender esto solo se necesita entender que un árbol de expresión es una estructura de datos como lo es una lista o una cola. Contiene un query LINQ to SQL, no los resultados del query, sino los elementos de dicho query.

Video: Existe un video que explica este artículo y puede ser visto aquí. 

Veamos este simple ejemplo de query LINQ to SQL :

var query = from customer in db.Customers  << El query
            where customer.City == "Paris" << no se ejecuta 
            select customer;               << aquí

Es fácil asumir que estas pocas líneas de código  ejecutan un query contra la base de datos. De hecho, no lo hacen. Este código apenas captura la idea de un query en una estructura de datos llamada árbol de expresión. Este árbol contiene información acerca de la tabla que se quiere consultar, la pregunta que quiere preguntar sobre la tabla, y la respuesta que quiere le sea retornada. Pero no hace, en ningún momento, la consulta efectiva a la base de datos.

En LINQ, la ejecución de un query es diferida hasta el momento preciso en que se solicitan los datos. Para nuestro ejemplo, las siguientes líneas de código provocarán que el query se ejecute:

foreach (var Customer in query) << El query se ejecuta aquí
{ 
	Console.WriteLine(Customer.CompanyName);
}

Las expresiones de query usualmente no causan que el código se ejecute. Solamente definen la pregunta que se quiere hacer. Si este no fuera el caso, entonces sería muy difícil o imposible para LINQ, converitr los queries en álgebra relacional que hace posible la composición, y que permite a los desarrolladores que les importa eso, optimizar su código. La ejecución diferida hace posible crear queries complejos de varios componentes sin gastar ciclos del cpu para efectivamente obtener los datos. O al menos, los datos no serán solicitados hasta que sea absolutamente necearios.

Hagamos un ligero cambio al ejemplo anterior: 

var query = (from customer in db.Customers << El query se ejecuta aquí
             where customer.City == “Paris”
             select customer).Count();

Esta vez, el query se ejecutará cuando el punto de ejecución pase por él. El código se ejecuta cuando se hace la llamada Count(), como si se hubiera hecho una llamada a cualquier otro operador que debe iterar sobre el resultado del query para obtener un valor que no es IEnumerableable<T> o IQueryable<T>. El operador ToList() del query se ejecuta inmediatamente porque devuelve un List<T> en vez de un IQueryable<T>. Consiere el siguiente código:

public void SimpleQuery01()
{
   db.Log = Console.Out;             // El query se ejecuta aquí y devuelve un List<T>
   List<Customer> list = (from customer in db.Customers
                          where customer.City == "Paris"
                          select customer).ToList();            foreach (var Customer in list)
   {
     Console.WriteLine(Customer.CompanyName);
   }
}

Una de las últimas cosas que el proveedor de LINQ to SQL hace antes de ejecutar un query es crear el SQL que será enviado por la red. Este hecho nos da una idea para tratar de determinar el momento exacto de cuando se ejecuta un query.

Asignando db.Log a Console.Out de la forma en que se hace en la primera línea del código, asegura que el SQL del query será escrito a la consola tan pronto como se ha generado. Cuando se ejecuta el código anterior, verá el log escrito en la pantalla tan pronto como la expresión de query se ejecuta. 

Considere el siguiente código, que no llama a ToList():

db.Log = Console.Out;   var query = from customer in db.Customers
             where customer.City == "Paris"
             select customer;   foreach (var Customer in query)  << El query se ejecuta aquí
{
   Console.WriteLine(Customer.CompanyName);
}

Si ejecuta el código anterior con el debugger mientras mira la ventana de consola, verá que el SQL no es generado hasta la ejecución de la sentencia foreach. Cuando se llama a ToList(), el SQL se escribe en la pantalla antes, dando la evidencia de que el query mismo se ejecuta antes:

List<Customer> list = (from customer in db.Customers
                        where customer.City == "Paris"
                        select customer).ToList(); << El query se ejecuta aquí 

Veamos ahoara la ejecución diferida desde un ángulo un poco diferente:

public void SimpleQuery03()
{
   string city = "London";        var query = from c in db.Customers
               where c.City == city
               select new { c.City };        city = "Madrid";    foreach (var q in query) << El query se ejecuta aquí 
   {
     Console.WriteLine(q);
   }
}

Este método mostrará Madrid en la pantalla, en vez de London. Al cambiar el valor de la variable city a Madrid, justo antes de la sentencia foreach, nos asegura que Madrid, en vez de London, se incluirá en el SQL que será enviado al servidor. El punto es que la expresión de query solamente genera un árbol de expresión, no envía el SQL a la base de datos.

Veamos ahora al ejemplo final, solo para aterrizar este muy importante punto. Considere el siguiente código:

public void DeleteInsert01()
{
   db.Log = Console.Out;    string customerId = "WIDGE";    // Expresión de query que se utilizará repetidamente 
   var query = from c in db.Customers
               where c.CustomerID == customerId
               select c;    Console.WriteLine("Count before insert: {0}", query.Count()); << Envío de SQL        // Inicializador del objeto
   var newCustomer = new Customer 
   {
     CustomerID = customerId,
     CompanyName = "Microsoft",
     ContactName = "John Doe",
     ContactTitle = "Sales Manager",
     Address = "1 Microsoft Way",
     City = "Redmond",
     Region = "WA",
     PostalCode = "98052",
     Country = "USA",
     Phone = "(425) 555-1234",
     Fax = null
   };        // Inserta 
   db.Customers.InsertOnSubmit(newCustomer);
   db.SubmitChanges();
   Console.WriteLine("Count after insert: {0}", query.Count()); << SEnvío de SQL        // Borra
   db.Customers.DeleteAllOnSubmit(query);
   db.SubmitChanges();
   Console.WriteLine("Count after delete: {0}", query.Count()); << Envío de SQL
}

La primera llamada a WriteLine() mostrará el número inicial de registros con su CustomerID del cliente WIDGE. El valor que devolverá será cero. La segunda llamada a WriteLine muestra el valor de 1, porque se ha insertado un registro. La llamada final mostrará nuevamente el valor de cero, porque el registro insertado fue borrado.

Note que la expresión de query usada para obtener la información de conteo del servidor fue escrita solamente una vez al principio del método.  En cada una de las tres llamadas a la sentencia WriteLine el query se compone con el operador Count() y se ejecuta. El siguiente SQL fue el enviado a la base de datos tres veces:

SELECT COUNT(*) AS [value]
FROM [dbo].[Customers] AS [t0]
WHERE [t0].[CustomerID] = @p0

Un SQL diferente fue enviado a la base de datos cuando se llamó al método DeleteAllOnSubmit. 

Suponga que reescribimos el método anteior para que luzca así: 

public void DeleteInsert02()
{
     db.Log = Console.Out;      string customerId = "WIDGE";      // La ejecución del query sucede aquí
     var query = (from c in db.Customers  << Se ejecuta el query
                  where c.CustomerID == customerId
                  select c).Count();      Console.WriteLine("Count before insert: {0}", query); << No se ejecuta      // Inicializador del objeto
     var newCustomer = new Customer
     {
         CustomerID = customerId,
         CompanyName = "Microsoft",
         ContactName = "John Doe",
         ContactTitle = "Sales Manager",
         Address = "1 Microsoft Way",
         City = "Redmond",
         Region = "WA",
         PostalCode = "98052",
         Country = "USA",
         Phone = "(425) 555-1234",
         Fax = null
     };            // Inserta
     db.Customers.InsertOnSubmit(newCustomer);
     db.SubmitChanges();
     Console.WriteLine("Count after insert: {0}", query); << No se ejecuta      var deleteQuery = from c in db.Customers
                       where c.CustomerID == customerId
                       select c;                  // Borra 
     db.Customers.DeleteAllOnSubmit(deleteQuery);
     db.SubmitChanges();
     Console.WriteLine("Count after delete: {0}", query); << No se ejecuta
}

Esta vez obtenemos el conteo de registros en la base de datos cuando la expresión de query se ejecuta al método. El valor correcto, que es cero, se devuelve de la base de datos en ese momento, y se muestra en la consola cuando la primera llamada a WriteLine se ejecuta. Cuando la segunda llamada a WriteLine se hace, el mismo valor cero que fue devuelto en el query inicial es mostrado. Como resultado, datos inválidos son reportados al usuario.

Esto ilustra porqué es tan importante el entender la ejecución diferida.

La ejecución diferida también es una espada de dos filos:

• Queries compuestos y la ejecución diferida trabajan juntos para hacer de LINQ un lenguaje de consultas rico e inusual. Si se entiende adecuadamente estas características de LINQ estará en posición de escribir menos código y ejecutarlo más rápido para poder lograr más.
• Como pudo haber notado, si no se entiende apropiadamente la ejecución diferida, entonces podemos terminar con muchos problemas. Los queries no se ejecutarán cuando esperamos que lo hagan y por ende podemos mostrar datos erróneos a los usuarios.

Conclusión: La ejecución diferida se aplica a todas las variedades de LINQ, incluyendo LINQ to SQL, LINQ to Objects y LINQ to XML. Sin embargo, de los tres, es solamente LINQ to SQL el único que devuelve un árbol de expresión por defecto. O más específicamente, devuelve una instancia de una interface IQueryable que referencia a un árbol de expresión. Un query que devuelve un IEnumerable aún soporta ejecución diferida, pero al menos una gran porción del resultado fue generado en comparación a LINQ to SQL. En otras palabras, LINQ soporta ejecución diferida, pero LINQ to SQL lo soporta de forma más completa que LINQ to Objects o LINQ to XML.

——————————————————————————————-
Obtenido del blog de Charlie Calvert (http://blogs.msdn.com/charlie/archive/2007/12/09/deferred-execution.aspx)

Un ejemplo sencillo de LINQ

Para el presente ejemplo, debemos crear una aplicación de Windows (la versión ASP.NET es similar solo que cambia el tipo de aplicación) común y corriente como las que usamos regularmente.

Esto nos presentará al solution explorer así:

Luego, tenemos que agregar un archivo LINQ to SQL así:

Para este ejemplo utilizaré la base de datos de ejemplo AdventureWorks, la que pueden descargar del sitio de proyectos públicos de Microosft “CodePlex” aquí.

Ahora, nos conectamos a la base de datos desde el Server Explorer:

Y simplemente seleccionamos una tabla y la arrastramos al archivo de LINQ. Esto nos dejará una pantalla similar a la siguiente:

Al ver las propiedades de este archivo, vemos una configuración importante y es referente al objeto DataContext que se crea automáticamente para el acceso a la base de datos:

Nosotros podemos cambiarle el nombre; es una propiedad reescribible, y recuerden que esto lo creó automáticamente LINQ como parte de la configuración de conexión. Ahora grabamos el proyecto y continuamos a trabajar con el WinForm Form1.cs.

Para ver los datos utilizaremos un control dataGridView que llamaremos dgvEmployees y en el evento Form_Load de dicha forma agregaremos el siguiente código:

private void Form1_Load(object sender, EventArgs e)
{
          AdventureWorksDataContext db = new AdventureWorksDataContext();
         dgvEmployees.DataSource = db.Employees;
}

Por último, compilamos y ejecutamos la aplicación que debe quedar algo así:

Bueno, espero que haya sido informativo y que les anime a intentar cosas más complejas con LINQ.

Hasta la próxima,

Evento MSDN Tour Guatemala

Pronto tendremos este evento en nuestra ciudad. Aca esta el calendario:

Lunes 10 de diciembre:

• 13:00 – 14:45: Arquitectura Orientada a Servicios (SOA) Cristian Prieto. Inscribirse
• 15:00 – 16:45: Silverlight para Diseñadores – Emy Alegre Inscribirse
• 17:00 – 18:45: C# 3.0 “The New Lambda Expressions” – Luis Alfaro Inscribirse
• 19:00 – 20:45: Web Service Software Factory Modeling Edition – Manolo Herrera Inscribirse

Martes 11 de diciembre:

• 13:00 – 14:45: Arquitectura de Factories – Cristian Prieto Inscribirse
• 15:00 – 16:45: Lo Nuevo de C# Completo en Visual Studio 2008 – Luis Alfaro Inscribirse
• 17:00 – 18:45: Optimizando Desarrollo Web con Vistual Studio 2008 – Carlos Lone Inscribirse
• 19:00 – 20:45: Cambios en C# y Visual Basic en Visual Studio 2008 – Marlon Ramos Inscribirse

Miércoles 12 de diciembre:

• 13:00 – 14:45: SmartClients y SmartClient Software Factory (SCSF) – Marlon Ramos Inscribirse
• 15:00 – 16:45: Silverlight para Desarrolladores – Carlos Lone Inscribirse
• 17:00 – 18:45: .Net Framework 3.5 – Cristian Prieto Inscribirse
• 19:00 – 20:45: Web Client Factories 2.0 – Manolo Herrera Inscribirse

Jueves 13 de diciembre:

• 13:00 – 14:45: Model View Controller Pattern – Carlos Lone Inscribirse
• 15:00 – 16:45: C# 3.0 [Extension Methods/ Partial Methods] – Luis Alfaro Inscribirse
• 17:00 – 18:45: Introducción a Open XML Marlon Ramos Inscribirse
• 19:00 – 20:45: Lo nuevo de Team System en Visual Studio 2008 – Manolo Herrera Inscribirse

Viernes 14 de diciembre:

• 13:00 – 14:45: Consideraciones de Arquitectura con Patrones de Diseño – Carlos Lone Inscribirse
• 15:00 – 16:45: Expression Studio Emy AlegreInscribirse
• 17:00 – 18:45: Windows Vista Goodies Cristian Prieto Inscribirse
• 19:00 – 20:45: LINQ – Lo último Marlon Ramos Inscribirse

Características de Visual Studio 2008 y .NET Framework 3.5

Para obtener la última versión de Visual Studio acá están los enlaces: 

Si es un suscriptor de MSDN o pertenece a una universidad con una suscripción de MSDN Academic Alliance puede obtener Visual Studio 2008 por medio del sitio de descargas. 

Si no es suscriptor de MSDN puede obtener una versión de evaluación de 90 días de Visual Studio Team Suite aquí. 

Si quiere utilizar las versiones gratuitas de Visual Studio 2008 Express Edition (que por  cierto son completamente gratis y mucho más pequeñas) puede descargarlas desde aquí. 

Si solo quiere utilizar el .NET Framework 3.5 puede descargarlo desde aquí.

Algunas de las nuevas características son:

Soporte Multi-Destino
VS2008 soporta configurar el destino de versión de .NET Framework que desee utilizar, por ejemplo puede crear, abrir y modificar aplicaciones del .NET Framework 2.0 en VS2008 sin problema alguno, así como aplicaciones de versiones 3.0 y 3.5.

ASP.NET AJAX y soporte para JavaScript
VS2008 incluye en su instalación ASP.NET AJAX (no se requiere una instalación adicional).

Diseñador Web y Soporte CSS
VS2008 y Visual Web Developer 2008 Express incluyen un mejorado diseñador de HTML (el mismo de Expression Blend) y puede manejar vistas divididas, código, visual, CSS anidados, etc.

Mejoras en los Lenguajes y LINQ
Los compiladores de Visual Basic y C# se optimizaron mucho y proveen grandes facilidades y mejoras al desarrollador.

——————————————————————————-
El contenido de este artículo fue tomado del blog de Scott Gutrhie (http://weblogs.asp.net/scottgu/archive/2007/11/19/visual-studio-2008-and-net-3-5-released.aspx)

NetFx3 – Microsoft .NET Framework 3.0 Community

Quisiera mostrarles este sitio de la comunidad de .NET Framework 3 (NetFx3).

http://netfx3.com/default.aspx

Tienen una cantidad bárbara de recursos para aprender sobre:

• Windows CardSpace
• Windows Presentation Foundation
• Windows Communication Foundation
• Windows Workflow Foundation

Además de recursos para ASP.NET AJAX, LINQ y Silverlight.

Espero les sirva