Visual Studio .net Framework 3.5 Para Profesionales - Maximiliano Firtman-librosvirtual.pdf 312v32

[email protected]

HQGSRLQWDGGUHVV KWWSORFDOKRVW'HVLJQB7LPH $GGUHVVHV:&)'HPR6HUYLFH ELQGLQJ ZV+WWS%LQGLQJ ELQGLQJ&RQ¿JXUDWLRQ :6+WWS%LQGLQJB,6HUYLFH FRQWUDFW 6HUYLFH3UR[\,6HUYLFH QDPH :6+WWS%LQGLQJB,6HUYLFH! LGHQWLW\! GQVYDOXH ORFDOKRVW! LGHQWLW\! HQGSRLQW!

para crear métodos de comparación de un tipo definido. Como podemos observar, hay una nueva notación: . Éste es el tipo que vamos a utilizar como parámetro, por ejemplo int o alguna otra clase que puede ser también definida por nosotros. Utilizar la letra T es simplemente una convención, no quiere decir que siempre tengamos que escribirla, bien podríamos reemplazarla por la letra U si quisiéramos. De hecho, vamos a ver más adelante que, en ciertas circunstancias, es necesario identificar el argumento mediante diferentes letras. Veamos algo de código que seguramente va a echar un poco de luz a este tema tan importante. En las siguientes líneas vamos a utilizar el tradicional ArrayList para definir una lista de nombres de personas:

Visual Studio - Firtman, Natale

Alfaomega

92

3- C# 3.0

using System; using System.Collections; using System.Text; 'H¿QLPRVQXHVWUR$UUD\/LVW ArrayList listaNombres = new ArrayList(); //Comenzamos a agregar algunos nombres listaNombres.Add("Leonardo Natale"); listaNombres.Add("Maximiliano Firtman"); // En tiempo de compilación, no obtenemos ningún error. listaNombres.Add(10); foreach (object nombre in listaNombres) { Console.WriteLine((string)nombre); } Console.Read();

Como podemos observar en este código, además de agregar dos nombres de personas, hemos agregado el valor 10, el cual al momento de compilar no devolvió ningún error. Cuando se ejecute la aplicación, obtendremos una excepción del tipo InvalidCastException, dado que ésta no puede convertir un tipo de datos System.Int32 a System.String. En realidad, en este caso nosotros no deberíamos agregar un valor del tipo int, dado que lo que estamos completando es una lista de nombres, pero como ArrayList espera un valor del tipo object, al momento de compilar no obtenemos ninguna advertencia, dado que todo hereda de ese tipo de dato. Obviamente, esto es un ejemplo muy sencillo de cómo una línea de código puede llegar a poner nuestro sistema inestable. Otra cosa que quizá hayan notado, es que estamos utilizando el espacio de nombres System.Collections, que es donde tenemos disponible ArrayList, en lugar de System.Collections.Generic. Veamos ahora cómo podríamos escribir el mismo ejemplo pero utilizando Generics: using System; using System.Collections.Generic; using System.Text; 'H¿QLPRVQXHVWUR/LVWIXHUWHPHQWHWLSDGRSDUDTXHDFHSWH datos del tipo string

Alfaomega


Características incorporadas en .NET Framework 2.0

93

// List<string> listaNombresGenerics = new List<string>(); listaNombresGenerics.Add("Leonardo Natale"); listaNombresGenerics.Add("Maximiliano Firtman"); // Error en tiempo de compilación listaNombresGenerics.Add(10); foreach (object nombre in listaNombresGenerics) { 1RWHPRVTXHQRHVQHFHVDULRUHDOL]DUXQFDVW Console.WriteLine(nombre); } Console.Read();

De esta manera, al compilar obtendremos un error que nos informa que estamos insertando en la lista un tipo de dato (en este caso int) para el cual la lista no fue definida. Lo interesante de este ejemplo no es solamente que podemos evitar el hecho de recibir una excepción cuando nuestro programa está ejecutándose, sino que nos ahorramos de tener que realizar conversiones entre tipos de datos y conversiones boxing y unboxing (desde y hacia el tipo base Object), lo cual significa una mejora de rendimiento –más aún, si nos encontramos en algún escenario donde debemos recorrer extensas colecciones–. Visual Studio –desde la versión 2005– al agregar un nuevo proyecto o una nueva clase nos agrega, también, la siguiente línea: using System.Collections.Generic; Es decir, no debemos hacer nada más para utilizar en nuestra solución Generics.

Ahora bien, como dijimos anteriormente, podemos tomar ventaja de los genéricos cuando creamos nuestros métodos y clases. Veamos algunos ejemplos. Nuestra primera clase genérica En el siguiente código vamos a generar un proyecto de consola y agregaremos una nueva clase (ClaseGenerica.cs), que posee una propiedad, llamada MyProperty, que puede adoptar diversos tipos de argumentos en función del valor que se le asigne a :


Alfaomega

94

3- C# 3.0

using System; using System.Collections.Generic; using System.Text; namespace EjemplosGenerics { class ClaseGenerica { private T myVar; public T MyProperty { get { return myVar; } set { myVar = value; } } public string Tipo { get { return typeof(T).ToString(); } } } }

Para que nos ayude en nuestro estudio, definimos una propiedad denominada Tipo, que nos devolverá el tipo de argumento que posee mediante la instrucción typeof. Utilizando ClaseGenérica Ya tenemos generada nuestra clase genérica; observemos un ejemplo de cómo utilizarla: class Program { static void Main(string[] args) { // Instanciamos nuestra clase y como tipo de valor le // pasamos un string ClaseGenerica<string> claseString = new ClaseGenerica<string>(); // Instanciamos nuestra clase y como tipo de valor OHSDVDPRVXQÀRDW &ODVH*HQHULFDÀRDW!FODVH)ORDW QHZ

Alfaomega



95

&ODVH*HQHULFDÀRDW! // Establecemos valores para nuestras propiedades claseString.MyProperty = "Esto es una cadena de texto"; claseFloat.MyProperty = 9.18f; // Enviamos a Consola valores y tipos Console.WriteLine("Valor de MyProperty de claseString es: {0}", claseString.MyProperty); Console.WriteLine("El tipo de es: {0}", claseString.Tipo); Console.Write("\n"); Console.WriteLine("Valor de MyProperty de claseFloat es: {0}", claseFloat.MyProperty); Console.WriteLine("El tipo de es: {0}", claseFloat.Tipo); Console.Read(); }

}

Ejecutemos la aplicación y observemos el resultado (figura 3.2). Cuando instanciamos nuestras clases, simplemente reemplazamos con el tipo de argumento en cuestión. En el ejemplo de arriba trabajamos con string: ClaseGenerica<string> claseString = new ClaseGenerica<string>();

Fig. 3-2. Resultado de utilizar nuestra clase genérica.


Alfaomega

96

3- C# 3.0

Y luego con float: &ODVH*HQHULFDÀRDW!FODVH)ORDW QHZ&ODVH*HQHULFDÀRDW!

De esta manera, reutilizamos nuestro código simplemente asignando un tipo de argumento. Y no sólo eso: Además, estamos proveyendo cierta seguridad a nuestra aplicación, dado que si hubiéramos escrito: FODVH)ORDW0\3URSHUW\ 8QWH[WRFXDOTXLHUD

al momento de compilar obtendríamos un error diciéndonos que no podemos convertir de un tipo string a un ÀRDW. Creando métodos genéricos Es posible crear métodos genéricos, tanto en clases genéricas como no genéricas, y pueden aceptar diversos valores en la firma del mismo: void MetodoGenerico(T var1, ref U var2, V var3) { // Cuerpo del método } T OtroMetodoGenerico (T var1, T var2) { // Cuerpo del método }

Veamos un ejemplo: class MiClase { // Creamos nuestro método genérico public T ObtenerMayor (T var1, T var2) where T : IComparable { if (var1.CompareTo(var2) > 0) return var1; return var2; } } //Utilizando nuestro método class Program { static void Main(string[] args) {

Alfaomega



97

MiClase c = new MiClase(); Console.WriteLine(c.ObtenerMayor(-2, -3)); Console.WriteLine(c.ObtenerMayor(109, 474)); Console.WriteLine(c.ObtenerMayor(23.5, 87.1)); Console.WriteLine(c.ObtenerMayor("Flavio", "Pablo")); Console.Read(); } }

Y el resultado será: -2 474 87,1 Pablo

Es importante que notemos que no hemos especificado el tipo de argumento al momento de llamar al método; esto se debe a que el compilador tiene la capacidad de poder inferir el tipo que se le está enviando. Otro detalle del código anterior es la aparición de la cláusula where: public T ObtenerMayor (T var1,T var2) where T:IComparable

Mediante la utilización de esta cláusula, lo que hacemos es definir una limitación o restricción para el tipo de parámetro T y, en este caso, estamos especificando que debe implementar la interface IComparable. Por consiguiente, si al llamar al método ObtenerMayor, el tipo de argumento de T que estamos fijando no implementa dicha interface, el compilador nos devolverá un error. Estamos ante otra forma de asegurar nuestro código. Generics es mucho más extenso que lo que aquí vimos; es realmente muy útil y nos va a facilitar mucho nuestra codificación. En el sitio de MSDN de Microsoft vamos a encontrar muchos más ejemplos e información relevante que fueron agregados sobre el tema. Es imprescindible interiorizarse para sacar partido de Generics.

Iteradores Es muy probable que muchos ya hayan trabajado con colecciones de objetos y habrán notado que a veces en determinados escenarios, al querer recorrer y acceder a los elementos del mismo, la implementación de la interface IEnumerator se tornaba complicada, y hasta a veces tediosa.


Alfaomega

98

3- C# 3.0

Debíamos implementar métodos como Reset o MoveNext para que todo funcionara correctamente y, mediante la propiedad Current, accedíamos a nuestros ítems. Luego, mediante el método GetEnumerator, proporcionado por la Interface IEnumerable, accedíamos a un enumerador que iteraba sobre la colección. Para facilitar esto, en la versión C# 2.0 se agregaron los iteradores, quienes nos van a permitir trabajar con clases iterables de forma muy sencilla, sin tener que implementar explícitamente IEnumerator en su totalidad. Qué son Un iterador puede ser un método, un operador o parte de un bloque de get{}, que nos va a habilitar para trabajar con clases o structs de manera muy sencilla y eficaz sin tener que codificar tantas líneas, como lo hacíamos cuando programábamos en .NET Framework 1.1, a través de sentencias foreach y retornándonos de forma ordenada una secuencia de valores del mismo tipo. Pero para entender un poco mejor qué son y cómo funcionan, veamos algo de código. Primer ejemplo: *HQHUDPRVQXHVWUDFODVHTXHFRQWLHQHXQDFROHFFLyQ // de marcas de autos class MarcaAutos { string[] arrMarcas = { "Subaru", "Audi", "BMW", "Porsche", "Ferrari", "Mercedes-Benz" }; public System.Collections.IEnumerator GetEnumerator() { for (int i = 0; i < arrMarcas.Length; i++) { yield return arrMarcas[i]; } } } // Nuestra clase Program donde vamos a iterar class Program { static void Main(string[] args) { MarcaAutos mAutos = new MarcaAutos(); foreach (string marca in mAutos)

Alfaomega



99

{ Console.Write(marca + " "); } Console.Read(); } }

La salida de esta aplicación de consola sería: Subaru Audi BMW Porsche Ferrari Mercedes-Benz

En la clase MarcaAutos nos vamos a encontrar con la implementación del método GetEnumerator de la interface IEnumerable, que devolverá, mediante la instrucción yield return, nuestro ítem. Luego, en Program.cs, foreach encapsulará la llamada por defecto a GetEnumerator y obtendremos los valores del enumerador. El ejemplo anterior podría ser escrito también de la siguiente forma, obteniendo la misma salida: class MarcaAutos { public System.Collections.IEnumerator GetEnumerator() { yield return "Subaru"; yield return "Audi"; yield return "BMW"; yield return "Porsche"; yield return "Ferrari"; yield return "Mercedez-Benz"; } } class Program { static void Main(string[] args) { MarcaAutos mAutos = new MarcaAutos(); foreach (string marca in mAutos) { Console.Write(marca + " "); } Console.Read(); } }


Alfaomega

100

3- C# 3.0

La palabra yield tiene otra opción: yield break. Esto nos va a permitir finalizar la enumeración que se está realizando ante, por ejemplo, una condición determinada: class MarcaAutos { string[] arrMarcas = { "Subaru", "Audi", "BMW", "Porsche", "Ferrari", "Mercedes-Benz" }; public System.Collections.IEnumerator GetEnumerator() { for (int i = 0; i < arrMarcas.Length; i++) { if (i == 3) { yield break; }; yield return arrMarcas[i]; } } }

La salida de consola sería: Subaru Audi BMW Si queremos utilizar otro nombre para el método GetEnumerator, podemos personalizarlo como se muestra a continuación: class Numeros { int[] arrNumeros = { 2, 5, 7, 9, 10, 8 }; // Reemplazamos IEnumerator por IEnumerable public System.Collections.IEnumerable ObtenerNumeros() { for (int i = 0; i < arrNumeros.Length; i++) { yield return arrNumeros[i]; } } } class Program { static void Main(string[] args) { Numeros nros = new Numeros();

Alfaomega

/ODPDPRVDOPpWRGRGH¿QLGR foreach (int nro in nros.ObtenerNumeros()) {



101

System.Console.Write(nro + " "); } Console.Read(); } }

También es importante tener en cuenta algunas restricciones cuando escribimos nuestros bloques de código en los iteradores: s

Un cláusula yield no puede estar dentro de un método anónimo (veremos más adelante de qué se trata).

s

Un método iterador debe retornar siempre IEnumerable, IEnumerator o sus correspondientes versiones de genéricos.

s

No puede poseer parámetros del tipo ref u out.

s

Yield no puede figurar dentro de un ¿QDOO\ de un try/catch.

s

Cuando es utilizado con expresiones, yield return no puede estar dentro de un bloque catch o dentro de un try que posee uno o más catch.

Iteradores + Genéricos: La unión hace la fuerza Hasta aquí hemos visto cómo construir nuestros bloques iteradores con clases no genéricas, utilizando para ello las interfaces que teníamos en System.Collections. La buena noticia es que disponemos también, dentro del ensamblado System. Collections.Generic, las interfaces IEnumerator e IEnumerable para poder trabajar con clases genéricas. Veamos cómo podemos reescribir los ejemplos anteriores utilizando clases genéricas e iteradores: // Generamos nuestra clase genérica class ClaseGenerica { T[] arrDatos; public ClaseGenerica(T[] datos) { arrDatos = datos; } public IEnumerator GetEnumerator() { foreach (T dato in arrDatos) yield return dato;


Alfaomega

102

3- C# 3.0

} } // La clase Program donde testearemos ClaseGenerica class Program { static void Main(string[] args) { int[] arrNumeros = { 2, 5, 7, 9, 10, 8 }; string[] arrMarcas = { "Subaru", "Audi", "BMW", "Porsche", "Ferrari", "Mercedes-Benz" }; ClaseGenerica genInt = new ClaseGenerica (arrNumeros); ClaseGenerica<string> genString = new ClaseGenerica<string>(arrMarcas); // Enviamos a consola el arreglo de números foreach (int nro in genInt) { System.Console.Write(nro + " "); } Console.Write("\n"); // Enviamos a consola el arreglo de marcas foreach (string marca in genString) { System.Console.Write(marca + " "); } Console.Read(); } }

Métodos Anónimos Hasta la versión anterior de C#, cuando trabajábamos con delegados hacíamos una especie de receta, donde uno de los puntos era definir el método que estábamos pasando como parámetro. Veamos un ejemplo sencillo: namespace MetodoAnonimo { 'H¿QLPRVQXHVWURGHOHJDGR delegate void MiDelegado(string texto); class Program { static void Main(string[] args) {

Alfaomega



103

// Enviamos como parámetro un método MiDelegado pruebaDel = new MiDelegado(Reemplazar); pruebaDel("Reemplazar espacios"); Console.Read(); } public static void Reemplazar(string a) { Console.WriteLine(a.Replace(' ','*')); } } }

Otra de las características que fueron incorporadas en la segunda versión del lenguaje son los Métodos Anónimos. Éstos nos van a permitir pasar una porción de código, en lugar del nombre de un método, como parámetro de un delegado. De esta manera, lo que haremos es reducir la sobrecarga de tener que escribir métodos exclusivamente para los delegados. ¿Arte de magia? No. Como varias de las características que veremos en este capítulo, el compilador es quien juega un papel protagónico, es un aliado de los programadores y facilita las tareas.Observemos como quedaría el ejemplo anterior, pero utilizando métodos genéricos: namespace MetodoAnonimo { 'H¿QLPRVQXHVWURGHOHJDGR delegate void MiDelegado(string texto);

class Program { static void Main(string[] args) { 'H¿QLPRVXQPpWRGRDQyQLPR MiDelegado pruebaDel = delegate(string a) { (OEORTXHGHFyGLJRGHOPpWRGR5HHPSOD]DU Console.WriteLine(a.Replace(' ','*')); }; pruebaDel("Reemplazar espacios en texto"); Console.Read(); } }

}


Alfaomega

104

3- C# 3.0

Algunas consideraciones s

Las variables locales que utilizamos dentro de un método anónimo son llamadas variables externas o capturadas, donde su ciclo de vida es igual al del delegado, es decir que cuando se cumplan las condiciones necesarias y actúe el recolector de basura, las mismas serán removidas.

s

Es necesario tener cautela cuando compartimos variables externas entre dos o más delegados, dado que es posible que obtengamos resultados inesperados.

s

El alcance de un método anónimo se encuentra limitado en su bloque de código.

s

No es posible utilizar variables ref u out con variables capturadas.

s

No se puede tener a código no seguro dentro del bloque.

Incorporaciones en C# 3.0 Métodos Parciales Los métodos parciales permiten definir un prototipo de método pero que podrá o no implementarse en la clase. No debe confundirse con la herencia o con una interface, dado que los métodos parciales son una implementación de precompilador. Si el compilador detecta que el método parcial se definió, pero no se implementó en ningún archivo de la clase (recordemos el concepto de clases parciales anteriormente visto), entonces elimina todas las llamadas a ese método, como si nunca hubieran existido. Si en cambio el método se definió, entonces se deja la invocación. Recordemos que hablamos siempre de la misma clase y no de la herencia o polimorfismo. ¿Qué objetivo tienen? Pueden ser útiles para métodos de depuración de código, para evitar utilizar interfaces y obligar a un a implementar métodos vacíos y, también, se utiliza para algunos de los nuevos frameworks, como ser el LINQ T o SQL, que veremos luego en este libro. El método sólo puede ser void, no debe contener código, debe incluir la cláusula partial en su prototipo –y no incluir ninguna cláusula en la implementación si existiera–, debe ser privado y puede ser de instancia o de clase (static). En un archivo podemos tener: public partial class Clase1 { public partial void Debug (string Txt); }

Alfaomega


Incorporaciones en C# 3.0

105

Y, opcionalmente, en otro archivo parcial de la misma clase podría estar la implementación: public partial class Clase1 { public partial void Debug (string Txt) { // Codigo a implementar } }

Cualquiera de las llamadas a ese método existirá en el compilado solamente si el método fue implementado. Si no, se evitan y no se compilan.

Tipos Implícitos La nueva inclusión de la instrucción var nos permitirá trabajar con variables cuyo tipo no es definido explícitamente –tal como lo hacíamos hasta ahora–, sino que el compilador será el responsable de deducir el tipo de la misma en función de lo que hayamos definido en el lado derecho de la inicialización. Así definíamos nuestras variables: namespace TiposImplicitos { class Program { static void Main(string[] args) { // Asignación explícita int valor = 1; string nombre = "Leonardo"; ÀRDWQXPHUR I Array arrProvincias = new string[] { "Buenos Aires", "San Juan" , "Mendoza"}; } } }

El mismo ejemplo con tipos implícitos: namespace TiposImplicitos { class Program { static void Main(string[] args) Visual Studio - Firtman, Natale

Alfaomega

106

3- C# 3.0

{ // Asignación implícita var valor = 1; var nombre = "Leonardo"; var numero = 3.5f; var arrProvincias = new string[] { "Buenos Aires", "San Juan" , "Mendoza"}; Console.WriteLine("Variable: valor.GetType().Name); Console.WriteLine("Variable: nombre.GetType().Name); Console.WriteLine("Variable: numero.GetType().Name); Console.WriteLine("Variable: {0}", arrProvincias.GetType().Name);

valor - Tipo: {0}", nombre - Tipo: {0}", numero - Tipo: {0}", arrProvincias - Tipo:

Console.Read(); } } }

La respuesta en la consola es lo que tenemos en la figura 3-3.

Fig. 3-3. El compilador infiere el tipo de las variables.

Veamos el código generado mediante la herramienta .NET Reflector (figura 3-4). Alfaomega



107

Fig. 3-4. Tipos implícitos en el desensamblador.

En la figura 3-4 notamos cómo el compilador deduce los tipos que no especificamos al utilizar la instrucción var, que son los mismos que obtuvimos en la pantalla de consola. Supongamos que definimos una variable que, implícitamente, es del tipo ÀRDW y luego le asignamos un texto; al momento de compilar obtendríamos un error: var miVariable = 4.8f PL9DULDEOH &XDOTXLHUWH[WR(UURU

Como miVariable es del tipo ÀRDW, el compilador nos devolvería un error informándonos que, correctamente, no puede convertir un tipo string a ÀRDW. Es importante tener en cuenta que: s

Siempre debemos inicializar las variables:

YDUPL9DULDEOH(UURU

s

Dada la restricción anterior, se deben inicializar en la misma instrucción:

YDUPL9DULDEOH(UURU PL9DULDEOH (UURU

s

No pueden establecerse como nulos:

YDUPL9DULDEOH QXOO(UURU

s

No está permitido inicializar más de una variable en la misma instrucción:

YDUPL9DULDEOHPL9DULDEOHPL9DULDEOH (UURU

s

No es posible utilizar como inicializador un objeto o una colección:

YDUPL9DULDEOH ^3DEOR5DSKDHO0LFKHODQJHOR`(UURU Visual Studio - Firtman, Natale

Alfaomega

108

3- C# 3.0

Inicializadores de objetos Una nueva funcionalidad ha sido agregada para ayudarnos al momento de tener que asignar un valor a campos, o propiedades accesibles, cuando creamos un objeto. Miremos cómo hacíamos antes para pasar algunos valores: class Producto { public Producto(){} private int _codigo; private string _nombre; private string _almacen; public int Codigo { get { return _codigo; } set { _codigo = value; } } public string Nombre { get { return _nombre; } set { _nombre= value; } } public string Almacen { get { return _almacen; } set { _almacen = value; } } } class Program { static void Main(string[] args) { Producto prod = new Producto(); //Asignamos un valor a cada propiedad prod.Codigo = 3005; prod.Nombre = "Aceite Vegetal"; prod.Almacen = "San Martín"; Console.WriteLine("Código: " + prod.Codigo); Console.WriteLine("Nombre: " + prod.Nombre); Console.WriteLine("Almacen: " + prod.Almacen); Console.Read(); } }

Alfaomega



109

Otra forma era pasar los valores por parámetro en el constructor: class Producto { public Producto(){} public Producto(int codigo, string nombre) { this.Codigo = codigo; this.Nombre = nombre; } private int _codigo; private string _nombre; private string _almacen; public int Codigo { get { return _codigo; } set { _codigo = value; } } public string Nombre { get { return _nombre; } set { _nombre= value; } } public string Almacen { get { return _almacen; } set { _almacen = value; } } }

class Program { static void Main(string[] args) { Producto prod = new Producto(3005, "Aceite Vegetal"); prod.Almacen = "San Martín"; Console.WriteLine("Código: " + prod.Codigo); Console.WriteLine("Nombre: " + prod.Nombre); Console.WriteLine("Almacen: " + prod.Almacen); Console.Read(); } }


Alfaomega

110

3- C# 3.0

Hasta aquí nada nuevo. Lo interesante es que mediante inicializadores de objetos vamos a poder definir nuestros valores en una misma instancia creacional, sin tener que invocar a su método en forma explícita, permitiéndonos escribir líneas mucho más claras. Reutilizando el mismo ejemplo anterior, quedaría así: class Producto { // Propiedades autoimplementadas public int Codigo { get; set; } public string Nombre { get; set; } public string Almacen { get; set; }

} class Program { static void Main(string[] args) { Producto prod = new Producto { Codigo = 3005, Nombre = "Aceite Vegetal", Almacen = "San Martín" };

Console.WriteLine("Código: " + prod.Codigo); Console.WriteLine("Nombre: " + prod.Nombre); Console.WriteLine("Almacen: " + prod.Almacen); Console.Read(); } }

En el ejemplo anterior se puede apreciar que, en lugar de escribir las propiedades con la “vieja receta”, se utilizaron propiedades auto implementadas. Esto no modifica la funcionalidad de la clase Producto, pero es otra modalidad de escribirlas que, quizá, sería bueno ir incorporando en el día a día. Obviamente, también es posible mantener la opción de utilizar una combinación de ambas, es decir, pasar algunos valores por parámetros en el constructor y otros mediante inicializadores de objetos (los que enviamos entre corchetes). Es importante aclarar que, empleando una mezcla de ambas, lo primero que se va a ejecutar será el constructor y luego serán enviados los valores de las propiedades en el orden en que fueron especificadas:

Alfaomega



111

class Producto { public Producto(int codigo) { this.Codigo = codigo; } // Propiedades autoimplementadas public int Codigo { get; set; } public string Nombre { get; set; } public string Almacen { get; set; }

} class Program { static void Main(string[] args) { Producto prod = new Producto(3005) { Nombre = "Aceite Vegetal", Almacen = "San Martín" };

Console.WriteLine("Código: " + prod.Codigo); Console.WriteLine("Nombre: " + prod.Nombre); Console.WriteLine("Almacen: " + prod.Almacen); Console.Read(); } }

Analicemos otro escenario, que al principio puede parecer complicado pero que no lo es. Supongamos que definimos una clase (VSHFL¿FDFLyQ, que posee algunas propiedades y queremos valorizarlas desde una propiedad de un objeto del tipo Producto, por ejemplo: FODVV(VSHFL¿FDFLRQ { public bool EsImportado { get; set; } public int Lote { get; set; } } class Producto { (VSHFL¿FDFLRQVSHFW QHZ(VSHFL¿FDFLRQ Visual Studio - Firtman, Natale

Alfaomega

112

3- C# 3.0

8QDSURSLHGDGGHOWLSR(VSHFL¿FDFLRQ SXEOLF(VSHFL¿FDFLRQ6SHFW^JHWÛHWXUQVSHFW`` // Propiedades autoimplementadas public int Codigo { get; set; } public string Nombre { get; set; } public string Almacen { get; set; } } class Program { static void Main(string[] args) { Producto prod = new Producto() { Codigo = 900, Nombre = "Aceite Girasol", Almacen = "Pilar", Spect = { EsImportado= true, Lote = 4 } }; Console.WriteLine("Código: " + prod.Codigo); Console.WriteLine("Nombre: " + prod.Nombre); Console.WriteLine("Almacen: " + prod.Almacen); Console.WriteLine("Es Importado: " + prod.Spect.EsImportado); Console.WriteLine("Lote: " + prod.Spect.Lote);

Console.Read(); } }

Resultado: Código: 900 Nombre: Aceite Girasol Almacen: Pilar Es Importado: True Lote: 4

Y en la figura 3-5 podemos apreciar cómo el IntelliSense de Visual Studio nos va aportando información sobre los tipos de datos y nombres de las propiedades definidas de nuestra clase Producto, así como también las escritas en (VSHFL¿FDFLRQFV. Alfaomega



113

Fig. 3-5. IntelliSense de Visual Studio utilizando inicializadores de objetos.

Trabajando con colecciones Podremos explotar también esta característica en nuestras colecciones que implementen IEnumerable o IEnumerable , mediante los inicializadores de objetos, tal como lo hemos hecho hasta aquí. class Program { static void Main(string[] args) { Producto[] maestroprods = new Producto[] { new Producto { Codigo=1000,Nombre="Aceto", Almacen="CABA", Spect={EsImportado=false,Lote=5} }, new Producto { Codigo=5009,Nombre="Aceite Oliva", Almacen="Pilar", Spect={EsImportado=true,Lote=90} }, }; foreach (Producto p in maestroprods) { Console.WriteLine("Código: " + p.Codigo); Console.WriteLine("Nombre: " + p.Nombre); Console.WriteLine("Almacen: " + p.Almacen); Console.WriteLine("Es Importado: " + p.Spect.EsImportado); Console.WriteLine("Lote: " + p.Spect.Lote);


Alfaomega

114

3- C# 3.0

} Console.Read(); } }

Ejecutando esta aplicación de consola, veríamos impreso en la pantalla: Código: 1000 Nombre: Aceto Almacen: CABA Es Importado: False Lote: 5 Código: 5009 Nombre: Aceite Oliva Almacen: Pilar Es Importado: True Lote: 90

Veamos ahora un ejemplo con Dictionary : Dictionary<string, bool> listaAsistencia = new Dictionary<string, bool> { {"Pablo",true},{"Diego",false},{"Fernando",true} };

De esta forma, logramos flexibilidad a la hora de trabajar con colecciones, ahorrándonos líneas de programación y permitiéndonos reutilizar y aprovechar al máximo todas las bondades de genéricos e inicializadores de objetos.

Tipos Anónimos Ahora que hemos visto cómo funcionan los tipos implícitos y los inicializadores de objetos, vamos a estudiar otra nueva característica de C# 3.0: Los tipos anónimos, que se basan, principalmente, en las dos características anteriores. Esta nueva característica nos va a permitir crear propiedades de modo implícito y asignarles un valor, pero que serán de sólo lectura. Básicamente, el compilador crea una clase del tipo anónimo con propiedades de un tipo que él va a inferir en función de nuestra declaración. Pero veamos un sencillo ejemplo: Alfaomega



115

class Program { static void Main(string[] args) { var celular = new { Marca = "Nokia", Modelo = "N95", CantVendida = 10, HayStock = true }; } }

Notemos el uso de la palabra var y de new. ¿Nos es familiar? Claro que sí, estamos utilizando por un lado tipos anónimos y luego los inicializadores de objetos, para asignarles valores a propiedades que serán generadas por el compilador on the fly. También, es posible notar que en el código anterior nunca creamos explícitamente ni una clase, ni un tipo de propiedad, ni el nombre de la misma, así como tampoco sus s (set y get). Recurramos a la herramienta .NET Reflector para observar algunas cosas interesantes que ocurren detrás de escena (figura 3-6).

Fig. 3-6. Tipo anónimo generado por el compilador. Visual Studio - Firtman, Natale

Alfaomega

116

3- C# 3.0

Lo primero que vamos a notar es el nombre del tipo anónimo que creó el compilador, en este caso “<>f__AnonymousType0”. El mismo es codificado en función del orden de las propiedades, sus tipos y cantidades que hayamos definido. Por deducción, podemos afirmar que cuando se altere alguna de estas condiciones, el compilador de C# generará n clases de n tipos según lo considere. Otro dato que tenemos son los campos privados con los nombres que especificamos entre los corchetes, así como también sus correspondientes propiedades. Como decíamos, estas propiedades son de sólo lectura; de hecho, si intentamos asignarles un valor luego de su inicialización, obtendremos un error en tiempo de compilación. Recomendamos que a las diversas conclusiones que podremos obtener, luego de analizar los resultados que nos brinda .NET Reflector, les dediquen unos minutos y naveguen en todo el árbol. Y para los curiosos, a través de ILDASM.exe tendrán disponible más información aún. A pesar de que a veces se torna complicado comprender lo que allí tenemos, es un punto interesante para indagar más sobre las cuestiones que ocurren al trabajar con tipos anónimos –que quizá no notemos–. Cuando es generada esta clase anónima, se sobrescriben tres métodos: Uno de ellos es ToString. En el ejemplo anterior el resultado sería (también lo podemos ver con .NET Reflector): public override string ToString() { StringBuilder builder = new StringBuilder(); builder.Append("{ Marca = "); builder.Append(this.<Marca>i Field); builder.Append(", Modelo = "); builder.Append(this.<Modelo>i Field); builder.Append(", CantVendida = "); builder.Append(this. i Field); builder.Append(", HayStock = "); builder.Append(this. i Field); builder.Append(" }"); return builder.ToString(); }

Para probarlo, agreguemos la siguiente línea y observemos la devolución: Console.Write(celular.ToString()); Console.Read();

Salida: Marca = Nokia, Modelo = N95, CantVendida = 10, HayStock

Alfaomega

= True



117

Supongamos ahora que queremos saber la cantidad total de dinero obtenido por las ventas realizadas; entonces, basándonos en el ejemplo anterior, podríamos hacer: int precioNokia = 100; var celular = new { Marca = "Nokia", Modelo = "N95", CantVendida = 10, HayStock = true }; var totalNokia = new { celular.Marca, Acumulado = celular.CantVendida * precioNokia }; Console.Write("Marca: {0} Acumulado: ${1}", totalNokia.Marca, totalNokia.Acumulado); Console.Read();

Lo interesante es que, al escribir totalNokia, el IntelliSense nos propone, además de la propiedad Acumulado, la opción Marca. Al no haber asignado un nombre para esta última, por defecto lo hereda de nuestra variable anónima celular.

Métodos extensores Los métodos extensores nos brindarán la posibilidad de agregar métodos a tipos existentes, sin tener que derivar de ellos o modificar su implementación original. Muchas veces esto último no es posible, dado que quizá estemos interesados en expandir las funcionalidades de un tipo del .NET Framework o de componentes de terceros. Crear métodos extensores es tan sencillo y fácil como crear cualquier otro método de instancia, con algunas pequeñas diferencias que se han de tener en cuenta: s

Deben ser estáticos al igual que la clase que los contiene.

s

Tienen que tener al menos un parámetro.

s

El primer parámetro de la firma debe tener antepuesto la palabra this.

s

El primer parámetro no puede tener modificadores como ref u out.

s

Siempre deben ser definidos en una clase no genérica.

s

No pueden estar en una clase anidada.

Veamos un simple ejemplo, donde vamos a extender el tipo string: Visual Studio - Firtman, Natale

Alfaomega

118

3- C# 3.0

namespace Miempresa.Extensores { static class Extensores { public static bool TieneNumero(this string x) { Regex regularEx = new Regex("[0-9]"); if (regularEx.IsMatch(x)) return true; return false; } } }

Básicamente, lo que hacemos es generar nuestra clase estática Extensores y nuestro método, estático también, TieneNumero. El objetivo de TieneNumero es devolver un tipo booleano, evaluando si la cadena de texto que se le envía como parámetro posee o no algún carácter comprendido entre 0 y 9. Notemos la palabra reservada this delante del tipo que queremos extender, en nuestro caso string. Se recomienda que los métodos extensores se encuentren en otro espacio de nombres, para poder identificarlos fácilmente y mantener una jerarquía ordenada de ellos. En nuestro caso es Miempresa.Extensores, que deberemos importar a nuestro ambiente de trabajo mediante un using para poder utilizarlos. En el siguiente bloque de código lo utilizamos de la siguiente manera: // Importamos el espacio de nombres using Miempresa.Extensores; namespace MetodosExtensores { class Program { static void Main(string[] args) { 'H¿QLPRVDOJXQDVFDGHQDVGHSUXHED string strPruebaConNumeros = "Ab3cd0EfG7HIJ9k"; string strPruebaSinNumeros = "AbcdEfGHIJk"; Console.WriteLine(strPruebaConNumeros.TieneNumero()); Console.WriteLine(strPruebaSinNumeros.TieneNumero()); Console.WriteLine("P0ds983jkd83D".TieneNumero()); Console.Read(); } } }

Alfaomega



119

Si ejecutamos este ejemplo, la respuesta sería: True False True

En la figura 3-7 podremos ver cómo el IntelliSense nos muestra el nuevo método estático generado y cómo lo distinguimos mediante un ícono nuevo.

Fig. 3-7. Métodos extensores definidos y su integración con el IntelliSense.

En ciertas circunstancias, nos encontramos ante una necesidad que no se resuelve, al menos de manera rápida y sencilla, con las funcionalidades que nos provee el .NET Framework. Y tal vez, aquella solución que implementamos para un proyecto la volvemos a codificar en otro, duplicando código y lidiando con problemas de escalabilidad y mantenimiento. En el ejemplo siguiente, agregamos una característica nueva a FileInfo (System.IO), que nos habilitará para copiar un archivo a un directorio destino, un directorio para resguardo y un parámetro para determinar si reemplazaremos o no el archivo en la carpeta de destino, en caso de tener uno con el mismo nombre: namespace Miempresa.Extensores { static class Extensores { public static void CopiarConDestinos(this System. IO.FileInfo archivo, string destArch, string destRes, bool reempplazar)


Alfaomega

120

3- C# 3.0

{ try { archivo.CopyTo(destArch, reempplazar); archivo.CopyTo(destRes, reempplazar); } catch (Exception ex) { // Loguear ex.Message; } } } }

La utilización sería como la siguiente: namespace MetodosExtensores { class Program { static void Main(string[] args) { 6\VWHP,2)LOH,QIR¿OH QHZ6\VWHP IO.FileInfo(@"C:\Prueba.txt"); ¿OH&RSLDU&RQ'HVWLQRV#&?1XHYD&DUSHWD?3UXHEDW[W @"C:\CarpetaBackup\PruebaBackup.txt",true); } } }

Es importante aclarar que no debemos hacer un mal uso de los métodos extensores; verifiquemos primero si no disponemos de la funcionalidad que estamos buscando, ya implementada de forma original. Por ejemplo, no tendría sentido que agreguemos uno de estos métodos a string con la finalidad de retornar una cadena en mayúsculas, dado que ya se encuentra desarrollada: string.ToUpper. De todas formas, imaginemos por un momento que extendemos el tipo string con un método llamado Replace, que recibe dos parámetros –uno es un char que contiene el carácter que ha de ser reemplazado y el segundo es otro char con el dígito con el cual reemplazaremos– y que cuando vamos a Alfaomega



121

utilizar este nuevo método, nos encontramos con que no está. El problema, aparentemente, reside en que ya existe uno con ese nombre; pero el problema, en realidad, es que posee la misma firma. Lo que ocurre es que, en un ámbito de trabajo, tiene mayor inferencia un método de instancia que un método extensor. Pero si de todas formas quisiéramos trabajar con el método extensor, podríamos llamarlo a través de su instancia estática como cualquier método. Ocurre algo parecido con los espacios de nombre, dado que los espacios de métodos extensores de menor profundidad poseen precedencia sobre los de mayor profundidad.

Expresiones Lambda Ahora que hemos visto las principales novedades y características de C# 2.0 y 3.0, quizá se torne complicado mostrar algunos ejemplos sin tener que mencionar LINQ, el cual será tratado más adelante. Dicho esto, nos adentraremos en los dos últimos temas: Expresiones Lambda y expresiones de consulta. Abordemos el tema de las expresiones Lambda: Éstas fueron incorporadas en C# 3.0 y nos van a permitir trabajar con delegados y métodos anónimos de una forma diferente de la que habíamos observado hasta ahora. Avanzaremos de a poco, para que su entendimiento sea lo más claro posible, e iremos aportando mayor complejidad a medida que comprendamos los conceptos. La sintaxis, a grandes rasgos, es parámetros de entrada => expresión/declaración, donde => es el operador lambda y cuya traducción programática sería algo como “va a“. Del lado izquierdo de este operador tendremos los parámetros de entrada, si es que los hay, y del lado derecho, nuestro bloque de declaración o expresión. Citamos el siguiente ejemplo, utilizando delegados para obtener el múltiplo de dos números: namespace ExpresionesLambda { class Program { delegate int Delegado(int a, int b); static void Main(string[] args) { Delegado miDel = new Delegado( delegate(int a, int b) { return a * b; }); Console.WriteLine("Resultado: " + miDel(4, 9)); Console.Read(); } } }


Alfaomega

122

3- C# 3.0

Hasta aquí nada extraño: Creamos nuestro delegado utilizando un método anónimo, tal como hemos visto hasta el momento. Ahora, tomando este mismo caso, vamos a escribirlo pero utilizando una expresión Lambda: namespace ExpresionesLambda { class Program { delegate int Delegado(int a, int b); static void Main(string[] args) { Delegado miDelLambda = (int c, int d) => c * d; Console.WriteLine("Resultado: " + miDelLambda (4, 9)); Console.Read(); } } }

Lo que hacemos es definir dos parámetros del tipo int y, luego del operador lambda, definimos nuestra expresión. Aquí disponemos también de la inferencia de tipos, dado que el compilador –inspeccionando la declaración del delegado– puede deducir con qué tipos estamos trabajando; por consiguiente, podríamos haber escrito de la siguiente manera, obteniendo el mismo resultado: Delegado miDelLambda = (c, d) => c * d;

De la manera que hemos codificado en el ejemplo de arriba, del lado derecho del operador tenemos una expresión que podría haber sido desarrollada mediante un bloque de declaración como el siguiente: Delegado miDelLambda = (c, d) => { return c * d; };

Supongamos ahora que simplemente vamos a trabajar con un solo valor como parámetro, donde el resultado será elevarlo al cuadrado. Podríamos, entonces, prescindir de los paréntesis en la declaración del lado izquierdo del operador lambda: OtroDelegado miDelLambda = n => Math.Pow(n,2);

Si no tuviéramos ningún parámetro como entrada, no escribiríamos nada entre los paréntesis: TuDelegado deleg = () => Console.WriteLine("Una prueba"); Alfaomega



123

Predicados y Proyecciones Cuando el objetivo de una expresión es obtener un resultado del tipo booleano, para determinar si se cumple tal o cual condición –o una relación de pertenencia– estamos ante la presencia de un predicado: nro => nro > 10;

Ahora, cuando la expresión retorna un tipo diferente al del predicado, se dice que es una proyección: miTexto => miTexto.Length; Delegados Func(T, TResult) y Action(T).

Quizá hayan notado que en todos los ejemplos que hemos escrito, donde utilizábamos delegados debíamos crearlos de forma explícita: delegate int Delegado(int x); Delegado miDel = n => n * 2;

Disponemos ahora de la posibilidad de escribir menos código y hacerlo más legible mediante dos opciones: s

Func(T, TResultado): Básicamente, este delegado encapsula un método con un número limitado de parámetros y devuelve un valor del tipo TResult, evitando así tener que crear un delegado en forma explícita. Obviamente, la firma del método debe coincidir con la definida en el delegado. Por ejemplo, basándonos en el código anterior, donde devolvíamos el producto de dos números, sería: Func Multiplicar = (int c, int d) => c * d; Console.WriteLine("Salida: " + Multiplicar(4, 9)); Console.Read();

s

Action(T): Es igual a Func , con la diferencia que no retorna un valor: namespace ExpresionesLambda { class Program { static void Main(string[] args) {


Alfaomega

124

3- C# 3.0

string nombreEdad = null; Action<string, int> NombreEdad = (e, f) => { nombreEdad = e + " - " + f.ToString(); }; NombreEdad("Pedro", 56); Console.WriteLine("Nombre y Edad: " + nombreEdad); Console.Read(); } } }

En la figura 3-8 podemos apreciar, mediante .NET Reflector, cómo el compilador hace el trabajo por nosotros.

Fig. 3-8. .NET Reflector nos muestra cómo el compilador infiere los tipos y genera el delegado de forma implícita.

Expresiones de consulta Las expresiones de consulta poseen su pilar en todo lo visto anteriormente, es por eso que las hemos dejado para el final. Aquí utilizaremos expresiones Lambda, inicializadores de objetos, métodos extensores y mucho más. Como no podía ser de otra manera, este tema está íntimamente ligado con LINQ, dado que es la herramienta que utilizaremos para nuestras consultas más adelante.

Alfaomega



125

Las expresiones de consulta nos van a permitir recuperar información de uno o más orígenes de datos, mediante una serie de instrucciones que luego manipularemos en nuestra aplicación. El resultado obtenido puede ser, además, una fuente de datos para otra consulta. Quienes trabajen con lenguajes SQL, notarán una gran similitud con ellos, aunque con algunas diferencias. Pero es importante destacar la posibilidad de realizar portabilidad de conocimientos, dado que nos ahorrará tiempos de aprendizaje en la adopción de este tipo de búsquedas. La primera diferencia que encontramos es que comienzan con la cláusula from en lugar de la clásica select, ubicándose ésta al final de la expresión. Para que podamos escribir nuestras consultas, el origen de los datos debe implementar IEnumerable o IQueryable . Veamos un simple ejemplo: namespace ExpresionesConsulta { class Program { static void Main(string[] args) { string[] arrPaises = { "Argentina", "Uruguay", "Alemania", "Canada", "Colombia" }; IEnumerable<string> varPaises = from pais in arrPaises where pais.StartsWith("A") orderby pais descending select pais; foreach (string pais in varPaises) { Console.WriteLine("Pais: " + pais); } Console.Read(); } } }

Resultado: Pais: Argentina Pais: Alemania


Alfaomega

126

3- C# 3.0

Lo primero que hacemos es declarar una variable (varPaises) que contenga el resultado de nuestra consulta y que, además, cumpla con la interface IEnumerable , para luego poder recorrer y obtener los valores esperados. Luego, comenzaremos a escribir nuestra expresión: Seguido de from especificamos una variable, denominada variable de rango, que infiere el tipo de dato, en este caso string, del contexto actual. Utilizamos in para declarar cuál es nuestra colección que contiene los datos que han de ser evaluados. Notemos cómo hemos hecho para filtrar el origen mediante la cláusula where. En este caso vamos a obtener todos los países de arrPaises[] que comiencen con la letra A y especificaremos, también, que el resultado esté ordenado (mediante orderby descending) en forma descendente. Supongamos otro caso. Pensemos que tenemos nuestra clase Cliente con tres propiedades: Código, Denominación y Provincia. Y necesitamos obtener todos los clientes cuyo código de identificación es mayor que 89. Observemos el siguiente bloque de código para entender cómo podríamos hacerlo: namespace ExpresionesConsulta { class Cliente { public int Codigo { get; set; } public string Denominacion { get; set; } public string Provincia { get; set; } } class Program { static void Main(string[] args) { List clientes = new List { new Cliente {Codigo=100, Denominacion="Pablo Ferreyra",Provincia="Catamarca"}, new Cliente {Codigo=89, Denominacion="Claudio Mess",Provincia="San Juan"}, new Cliente {Codigo=509, Denominacion="Diego Pacce",Provincia="Catamarca"}, new Cliente {Codigo=22, Denominacion="Nora Díaz",Provincia="Misiones"}, }; var listClientes = from cli in clientes where cli.Codigo > 90 select new { Nombre = cli.Denominacion, Prov = cli.Provincia }; foreach (var cliente in listClientes) {

Alfaomega



127

Console.WriteLine("Nombre: {0} Provincia: {1}", cliente.Nombre, cliente.Prov); } Console.Read(); } } }

Detengámonos en la definición de la consulta: ¿No notan algo extraño pero ya conocido? Sí, estamos utilizando tipos anónimos e inicializadores de objetos. Quizá, lo que muchos se estarán preguntando es cómo se interpreta esta especie de código SQL para que pueda ser ejecutado. Básicamente, C# traduce las sentencias de consulta en invocaciones de métodos de instancias o extensores, como por ejemplo Select, Where u OrderBy. Cada uno de ellos responde a un patrón de consultas y, mediante un mapeo entre sentencia y método, saben cómo deben procesar cada una de las instrucciones que hemos escrito. De hecho, podemos escribir nuestras consultas en notación de métodos y para muchos, quizá, les resulte más fácil o entendible hacerlos de esta manera. En el código que se presenta a continuación, vemos cómo sería escribir el ejemplo anterior pero con métodos: class Program { static void Main(string[] args) { List clientes = new List { new Cliente {Codigo=100, Denominacion="Pablo Ferreyra",Provincia="Catamarca"}, new Cliente {Codigo=89, Denominacion="Claudio Mess",Provincia="San Juan"}, new Cliente {Codigo=509, Denominacion="Diego Pacce",Provincia="Catamarca"}, new Cliente {Codigo=22, Denominacion="Nora Díaz",Provincia="Misiones"}, }; var listClientesMetodos = clientes. Where(c => c.Codigo > 89). Select(c => new { Nombre = c.Denominacion, Prov = c.Provincia });


Alfaomega

128

3- C# 3.0

foreach (var cliente in listClientesMetodos) { Console.WriteLine("Nombre: {0} Provincia: {1}", cliente.Nombre, cliente.Prov); } Console.Read(); } }

Existen aún más opciones para escribir nuestras consultas, pero las desarrollaremos en el capítulo de LINQ.

Alfaomega


129

Visual Basic 2008

4

Introducción Todos conocemos al viejo y querido Visual Basic, conocido también como VB. Originalmente, dueño de su propia plataforma y utilizado ampliamente en desarrollo de aplicaciones de escritorio bajo tecnología Microsoft, fue evolucionando de manera considerable hasta convertirse en un poderoso y flexible lenguaje de programación para realizar cualquier tipo de desarrollos en la actualidad. Todavía son miles los programadores Visual Basic 6.0 que no han evolucionado con las versiones .NET de la plataforma. Desde aquí, un incentivo enorme a aquellos que no lo han hecho. Este es el momento de evolucionar y no quedar una década atrás en el mundo del desarrollo.

La evolución en VB La primera versión del lenguaje fue creada en 1991 por Microsoft, a partir del todavía más antiguo lenguaje Basic, con el objetivo de ofrecer una plataforma de creación de aplicaciones gráficas para DOS y luego para el Windows, todavía incipiente. Durante diez años más, Visual Basic se convirtió en el lenguaje más utilizado para la creación de aplicaciones Win32, o aplicaciones ejecutables para la plataforma Windows. En ese sentido, Visual Basic 6.0 fue la plataforma más utilizada en el mercado, si la comparamos con Borland Delphi o C++. Desde el año 2001 Microsoft decidió suspender su plataforma Win32 para Windows y así ingresar con todas sus fuerzas a la plataforma .NET –con todas las ventajas que eso trajo–. A partir de la versión 7.0, conocida como Visual Basic.NET, Visual Studio - Firtman, Natale

Alfaomega

130

4- Visual Basic 2008

se decidió dar un corte fundamental en el mundo de la programación VB. El código de VB 7.0 no sería compatible con el de 6.0. Fue una decisión difícil, pero necesaria. Así, Visual Basic entró en la lista de lenguajes tipados, totalmente orientados a objetos y con las mismas posibilidades que lenguajes como C# o Java. De hecho, del viejo Visual Basic 6.0 de 1998 al actual Visual Basic queda poco en común, por lo que incluso para la eterna enciclopedia en línea Wikipedia son lenguajes distintos.

Fig. 4-1. Captura de pantalla de Microsoft Visual Basic 1.0 para DOS en 1991. No estamos tan lejos, ¿o sí?

Entonces, la vida del lenguaje que nosotros llamaremos Visual Basic, el moderno, comenzó con Visual Basic .NET (VB 7.0) en 2002, pasando por Visual Basic 2003 (VB 7.1), Visual Basic 2005 (VB 8.0), Visual Basic 2008 (VB 9.0) y el futuro Visual Basic VBx (VB 10.0).

Visual Basic .NET Si todavía queda algún programador rezagado de Visual Basic 6.0, daremos un repaso por las principales características del nuevo lenguaje desde la versión .NET: s

No genera más aplicaciones .EXE para Windows que requieran los famosos DLLs del runtime de Visual Basic.

Alfaomega



131

s

Compila para el CLR (Common Language Runtime), generando aplicaciones .EXE para plataforma .NET, aplicaciones Web para ASP.NET, aplicaciones móviles para .NET Compact Framework, aplicaciones Web para Silverlight y otros.

s

Es un lenguaje totalmente orientado a objetos.

s

Sólo funciona sobre el .NET Framework, incluyendo los tipos de datos de esta plataforma y al 100% de las clases y funcionalidades.

s

Las clases o paquetes compilados pueden interactuar con total compatibilidad con otros paquetes desarrollados en otros lenguajes .NET, incluyendo C#.

s

No existe más el tipo de datos Variant, reemplazado en su concepto similar por Object.

s

Son obligatorios los paréntesis en llamados a funciones y métodos.

s

No funcionan más los operadores Set y Let.

s

Los tipos de datos siguen vigentes, aunque se tratan de alias a las clases de .NET, por ejemplo, Integer estará representando a System.Int32.

s

Por compatibilidad se dejaron algunas funciones globales que son alias a llamadas a métodos del .NET Framework. No obstante, se recomienda utilizar la versión nueva.

s

Option Explicit está definido en On por defecto, lo que nos obliga a declarar todas las variables antes de usarlas.

Características incorporadas en .NET Framework 2.0 El .NET Framework 2.0 es considerado un cambio muy importante en la plataforma de Microsoft, en cuanto a soporte y tiempo de desarrollo. Visual Basic 2005 (VB 8) tampoco se ha quedado atrás en la implementación de estas novedades.

Genéricos Quizá para muchos, los genéricos sean una de las características más importantes agregadas en la versión 2.0. Si bien Visual Basic, comparado con C#, es un poco menos estricto en cuanto al cast de tipos de dato, la mala utilización de estos tipos de dato nos Visual Studio - Firtman, Natale

Alfaomega

132


provoca degradación de rendimiento, así como posibles excepciones en tiempo de ejecución. Recordemos que los genéricos nos van a permitir escribir, de forma fuertemente tipada, colecciones, clases y métodos tal como se lo hace en otros lenguajes como Java o C#. Disponemos ahora de un nuevo espacio de nombres: System.Collections.Generic que contiene varias interfaces y clases basadas en tipos genéricos, para poder generar nuestras colecciones inflexibles. En el espacio de nombres System tenemos IComparable(Of T) para crear métodos de comparación de un tipo definido. Como podemos observar, hay una nueva notación: (Of T). Éste es el tipo que vamos a utilizar como parámetro, por ejemplo Integer o alguna otra clase que puede ser también definida por nosotros. Utilizar la letra T es simplemente una convención, no quiere decir que siempre tengamos que escribirla, bien podríamos reemplazarla por la letra U si quisiéramos. De hecho, vamos a ver más adelante que, en ciertas circunstancias, es necesario identificar el argumento mediante diferentes letras. Veamos algo de código, que seguramente va a echar un poco de luz a este tema tan importante. En las siguientes líneas vamos a utilizar el tradicional ArrayList para definir una lista de nombres de personas:

'H¿QLPRVQXHVWUR$UUD\/LVW Dim listaNombres As New ArrayList()

&RPHQ]DPRVDDJUHJDUDOJXQRVQRPEUHV listaNombres.Add("Leonardo Natale") listaNombres.Add("Maximiliano Firtman") 'En tiempo de compilación, no obtenemos ningún error. listaNombres.Add(10) For Each Nombre In listaNombres Console.WriteLine(CStr(Nombre)) Next Console.Read()

Como podemos observar en este código, además de agregar dos nombres de personas, hemos agregado el valor 10, el cual al momento de compilar no devolvió ningún error. Cuando se ejecute la aplicación, obtendremos una excep-

Alfaomega



133

ción del tipo InvalidCastException, dado que no puede convertir un tipo de datos System.Int32 a System.String al utilizar el cast CStr. En realidad, en este caso nosotros no deberíamos agregar un valor del tipo Integer, dado que lo que estamos completando es una lista de nombres. Pero como ArrayList espera un valor del tipo Object al momento de compilar no obtenemos ninguna advertencia, dado que todo hereda de ese tipo de dato. Obviamente esto es un ejemplo muy sencillo de cómo una línea de código puede llegar a poner nuestro sistema inestable. Veamos ahora cómo podríamos escribir el mismo ejemplo pero utilizando Generics: Imports System.Collections.Generic;

'H¿QLPRVQXHVWUR/LVWIXHUWHPHQWHWLSDGRSDUDTXHDFHSWHGDWRV 'del tipo String. Se lee "lista de string" Dim listaNombresGenerics As New List(Of String) listaNombresGenerics.Add("Leonardo Natale") listaNombresGenerics.Add("Maximiliano Firtman") ' Error en tiempo de compilación listaNombresGenerics.Add(10) For Each Nombre As String In listaNombresGenerics {

1RWHPRVTXHQRHVQHFHVDULRUHDOL]DUXQFDVW Console.WriteLine(Nombre) } Console.Read()

De esta manera, al compilar obtendremos un error que nos informa que estamos insertando en la lista un tipo de dato (en este caso Integer) para el cual la lista no fue definida. Por defecto, al agregar un nuevo proyecto o una nueva clase, ya tenemos agregado el namespace para genéricos, por lo que nos evitaríamos tener que realizar: Imports System.Collections.Generic La siguiente tabla muestra algunas de las colecciones de la versión 1.1 y su par en Generics, utilizando la sintaxis de Visual Basic.


Alfaomega

134


.NET 1.x

.NET 2.0

ArrayList

List(Of T)

Hashtable

Dictionary(Of K,V)

SortedList

SortedList(Of K,V)

Stack

Stack(Of T)

Ahora bien, como dijimos anteriormente, podemos tomar ventaja de los genéricos cuando creamos nuestros métodos y clases. Veamos algunos ejemplos. Nuestra primera clase genérica En el siguiente código vamos a generar un proyecto de consola y agregaremos una nueva clase (ClaseGenerica.vb), que posee una propiedad llamada MyProperty que puede adoptar diversos tipos de argumentos en función del valor que se le asigne a (Of T): Namespace EjemplosGenerics Class ClaseGenerica(Of T) Private myVar As T 3XEOLF3URSHUW\0\3URSHUW\ $V7 Get 5HWXUQP\9DU End Get 6HW%\9DOYDOXH$V7 P\9DU YDOXH End Set End Property 3XEOLF5HDG2QO\3URSHUW\7LSR $V6WULQJ Get 5HWXUQ*HW7\SH7 7R6WULQJ End Get End Property End Class End Namespace

Para que nos ayude en nuestro estudio, definimos una propiedad denominada Tipo, que nos devolverá el tipo de argumento que posee (Of T) mediante la instrucción GetType.

Alfaomega



135

Utilizando clase genérica Ya tenemos generada nuestra clase genérica, observemos un ejemplo de cómo utilizarla:

,QVWDQFLDPRVQXHVWUDFODVH\FRPRWLSRGHYDORUOHSDVDPRVXQ ' string Dim claseString As New ClaseGenerica(Of String)

,QVWDQFLDPRVQXHVWUDFODVH\FRPRWLSRGHYDORUOHSDVDPRVXQ ' Single Dim claseSingle As New ClaseGenerica(Of Single)

(VWDEOHFHPRVYDORUHVSDUDQXHVWUDVSURSLHGDGHV FODVH6WULQJ0\3URSHUW\ (VWRHVXQDFDGHQDGHWH[WR claseFloat.MyProperty = 9.18F ' Enviamos a Consola valores y tipos Console.WriteLine("Valor de MyProperty de claseString es: {0}",_ claseString.MyProperty) Console.WriteLine("El tipo de T es: {0}", claseString.Tipo) Console.Write(vbCrLf) Console.WriteLine("Valor de MyProperty de claseSingle es: {0}",_ claseFloat.MyProperty) Console.WriteLine("El tipo de T es: {0}", claseFloat.Tipo) Console.Read()

Ejecutemos la aplicación y observemos el resultado (figura 4-2).

Fig. 4-2. Resultado de utilizar nuestra clase genérica. Visual Studio - Firtman, Natale

Alfaomega

136


Cuando instanciamos nuestras clases, simplemente reemplazamos (Of T) con el tipo de argumento en cuestión. En el ejemplo de arriba, trabajamos con String: Dim Clase String As ClaseGenerica(Of String) = New_ ClaseGenerica(Of String)

O la versión reducida: Dim Clase String As New ClaseGenerica(Of String)

Y luego con Single: Dim ClaseSingle As New ClaseGenerica(Of Single)

De esta manera, reutilizamos nuestro código simplemente asignando un tipo de argumento. Y no sólo eso, sino que, además, estamos proveyendo cierta seguridad a nuestra aplicación, dado que si hubiéramos escrito: &ODVH6LQJOH0\3URSHUW\ 8QWH[WRFXDOTXLHUD

al momento de compilar obtendríamos un error diciéndonos que no podemos convertir de un tipo String a un Single. Creando métodos genéricos Es posible crear métodos genéricos tanto en clases genéricas como no genéricas y pueden aceptar diversos valores en la firma del mismo: 3ULYDWH6XE0HWRGR*HQHULFR%\9DOYDU$V7%\5HIYDU$V8B ByVal var3 As V) &XHUSRGHOPpWRGR (QG6XE 3ULYDWH)XQFWLRQ2WUR0HWRGR*HQHULFR2I7 (ByVal var1 As T, ByVal var2 As T) As T &XHUSRGHOPpWRGR (QG)XQFWLRQ

Veamos un ejemplo: Class MiClase &UHDPRVQXHVWURPpWRGRJHQpULFR 3XEOLF)XQFWLRQ2EWHQHU0D\RU2I7$V,&RPSDUDEOH (ByVal var1 As T, ByVal var2 As T) As T If var1.CompareTo(var2) > 0 Then 5HWXUQYDU End If Alfaomega



137

5HWXUQYDU (QG)XQFWLRQ End Class

8WLOL]DQGRQXHVWURPpWRGR Dim c As New MiClase() Console.WriteLine(c.ObtenerMayor(-2, -3)) Console.WriteLine(c.ObtenerMayor(109, 474)) Console.WriteLine(c.ObtenerMayor(23.5, 87.1)) Console.WriteLine(c.ObtenerMayor("Flavio", "Pablo")) Console.Read()

Y el resultado será: -2 474 87,1 Pablo

Es importante que notemos que no hemos especificado el tipo de argumento al momento de llamar al método, esto se debe a que el compilador tiene la capacidad de poder inferir el tipo que se le está enviando. Entonces, logramos evitar el hecho de realizar varias sobrecargas para un método similar. Otro detalle del código anterior es la aparición de la cláusula As: 3XEOLF)XQFWLRQ2EWHQHU0D\RU2I7$V,&RPSDUDEOH Mediante la utilización de esta cláusula, lo que haremos será definir una limitación o restricción para el tipo de parámetro T y, en este caso, estaremos especificando que debe implementar la interface IComparable. Por consiguiente, si al llamar al método ObtenerMayor, el tipo de argumento de T que estamos fijando no implementa dicha interface, el compilador nos devolverá un error. Esta es otra forma de asegurar nuestro código. Generics es mucho más extenso que lo que aquí vimos, es realmente muy útil y nos va a facilitar mucho nuestra codificación. En el sitio de MSDN de Microsoft, vamos a encontrar muchos más ejemplos e información relevante que fueron agregados sobre el tema. Es imprescindible interiorizarse para sacar partido de Generics.

Clases Parciales Las clases parciales son un concepto simple, pero muy útil. Una clase parcial es aquella cuya definición está dividida, físicamente, en más de un archivo. Para el compilador el uso de la clase es exactamente igual. Sólo nos permite trabajar Visual Studio - Firtman, Natale

Alfaomega

138


de mejor forma cuando lo hacemos en capas o en trabajos en equipo, pudiendo tener bien separados ambos archivos. Todas las partes de la clase deben estar en el mismo lenguaje. En ASP.NET esto trajo una gran solución: Que una página Web de tipo Code-Behind pueda trabajar internamente como una sola clase dividida en dos archivos. La sintaxis incorpora el operador Partial: 3XEOLF3DUWLDO&ODVV1RPEUH End Class

Objeto My El nuevo namespace exclusivo de Visual Basic, My (Mi en español), permite acceder a distintas funcionalidades del .NET Framework de una forma más fácil y accesible. Pensemos en este objeto (ya instanciado) como directo a distintos puntos del árbol jerárquico de clases .NET. Por ejemplo, podemos leer el texto de un archivo de disco: 'LPWH[WRDV6WULQJ 0\&RPSXWHU)LOH6\VWHP5HDG$OO7H[W ("C:\Texto.txt")

Fig. 4-3. La estructura de objetos disponibles en My. Alfaomega



139

El a los distintos objetos disponibles está íntimamente relacionado con el tipo de proyecto (ASP, Windows Form, etc.). Objetos Disponibles Objeto

Descripción

My.Application

Obtiene propiedades y métodos sobre la aplicación en ejecución.

0\&RPSXWHU

Permite acceder al nombre y pantalla del equipo.

0\&RPSXWHU$XGLR

Permite acceder a la reproducción y propiedades de audio.

0\&RPSXWHU&OLSERDUG

Obtiene al portapapeles de Windows.

0\&RPSXWHU&ORFN

Obtiene al reloj del equipo.

0\&RPSXWHU FileSystem

Permite acceder al sistema de archivos, con funciones para leer, copiar, grabar archivos y carpetas.

0\&RPSXWHU,QIR

Accede a información de la memoria y sistema operativo.

0\&RPSXWHU.H\ERDUG

Accede a información del teclado y su uso.

0\&RPSXWHU0RXVH

Accede a información actual del mouse.

0\&RPSXWHU1HWZRUN

Accede a funciones y eventos relacionados con la red.

0\&RPSXWHU3RUWV

Permite acceder a puertos seriales del equipo.

0\&RPSXWHU5HJLVWU\

Obtiene al registro de Windows.

My.

Permite acceder a información del actualmente identificado.

0\5HTXHVW

En ASP.NET permite acceder al requerimiento de la petición.

My.Response

En ASP.NET permite acceder a la respuesta hacia el cliente.

My.Form

En Windows Forms permite acceder a funcionalidades respecto de los formularios y ventanas de la aplicación.

0\5HVRXUFHV

Permite acceder a los recursos de la aplicación (no disponible en ASP.NET.)

My.Settings

Permite acceder a información y utilidades respecto de la configuración de la aplicación (no disponible en ASP.NET).

My.WebServices

Permite acceder a las funcionalidades rápidas de servicios Web (no disponible en ASP.NET).

La siguiente tabla muestra la compatibilidad de los objetos, según el tipo de proyecto:


Alfaomega

140


Objetos My. Application 0\&RPSXWHU My. Forms My. Log 0\5HTXHVW 0\5HVRXUFHV My. Response My. Settings My. My. WebServices

Windows

DLL Windows

Sitio Web

Controles Web

9 9 9 2 2 9 2 9 9 9

9 9 9 2 2 9 2 9 9 9

2 9 2 9 9 2 9 2 9 2

2 9 2 2 2 9 2 9 9 9

Sobrecarga de operadores Una de las funciones avanzadas más pedidas era la sobrecarga de operadores, así que, desde Visual Basic 2005, también es posible definir operaciones –como la suma o la negación– sobre clases creadas por nosotros mismos. Hagamos la clásica clase 1XPHUR&RPSOHMR, representando a los números complejos matemáticos: &ODVV1XPHUR&RPSOHMR &RQVWUXFWRU 3XEOLF6XE1HZ%\9DOUHDO$V'RXEOH%\9DOLPDJLQDULR$VB 'RXEOH x = real y = imaginario (QG6XE 3XEOLF2YHUULGHV)XQFWLRQ7R6WULQJ $V6WULQJ Dim s As String If y >= 0 Then s = x + " + " + y + "i" Else s = x + " - " + -1*y + "i" End If 5HWXUQV (QG)XQFWLRQ 3XEOLF3URSHUW\5HDO $V'RXEOH Get 5HWXUQ[ End Get

Alfaomega



141

6HW%\9DO9DOXH$V'RXEOH [ 9DOXH End Set End Property 3XEOLF3URSHUW\,PDJLQDULR $V'RXEOH Get 5HWXUQ\ End Get 6HW%\9DO9DOXH$V'RXEOH \ 9DOXH End Set End Property 3ULYDWH[$V'RXEOH 3ULYDWH\$V'RXEOH End Class

Ahora queremos sumar estos números complejos sin necesidad de recurrir a un clásico método de instancia llamado 6XPD, que reciba otro complejo, o un método de clase (shared), que reciba ambos. 'Opcion 1 3XEOLF)XQFWLRQ6XPD%\9DO2WUR&RPSOHMR$V1XPHUR&RPSOHMR $VB 1XPHUR&RPSOHMR 'Opcion 2 3XEOLF6KDUHG)XQFWLRQ6XPD%\9DO&RPSOHMR$V1XPHUR&RPSOHMR %\9DO&RPSOHMR$V1XPHUR&RPSOHMR $V1XPHUR&RPSOHMR

Para utilizar los ejemplos anteriores, haríamos algo así: 'LP&RPSOHMR$V1HZ1XPHUR&RPSOHMR 'LP&RPSOHMR$V1HZ1XPHUR&RPSOHMR 'LP6XPD$V1XPHUR&RPSOHMR 'Para 6XPD 'Para 6XPD

la opción 1 &RPSOHMR6XPD&RPSOHMR la opción 2 1XPHUR&RPSOHMR6XPD&RPSOHMR&RPSOHMR

¿No sería más legible utilizar el siguiente código? 6XPD &RPSOHMR&RPSOHMR

Entonces, hagamos una sobrecarga de operadores como el siguiente ejemplo, dentro de la clase 1XPHUR&RPSOHMR: Visual Studio - Firtman, Natale

Alfaomega

142


3XEOLF6KDUHG2SHUDWRU&RPSOHMR$V1XPHUR&RPSOHMR&RPSOHMRB $V1XPHUR&RPSOHMR $V1XPHUR&RPSOHMR 'LP5HVXOWDGR$V1HZ1XPHUR&RPSOHMRB Complejo1.Real + Complejo2.Real, _ Complejo1.Imaginario + Complejo2.Imaginario) 5HWXUQ5HVXOWDGR End Operator

Los operadores que se pueden sobrescribir para nuestra clase son: Operadores Unarios (un parámetro) 1RW,V7UXH,V)DOVH&7\SH

Operadores Binarios (dos parámetros) ? /LNH0RG$QG2U;RU ^ << >> = <> > < >= <=

Otros cambios menores Operador IsNot Simplifica muchas expresiones lógicas y equivale a utilizar Not … Is, por ejemplo: If Not objeto Is Nothing then Se reemplaza por If objeto IsNot Nothing then Definición de Arrays Como ya sabemos, los vectores en .NET empiezan de la posición 0. En Visual Basic definir un vector producía mucha confusión si la definición daba la cantidad de elementos o el límite superior, entonces desde VB 8 es posible declarar un vector de la siguiente forma más clara: Dim vector(0 to 9) As String Instrucción Continue Indica en un bucle que continúe a la siguiente iteración.

Alfaomega


Incorporaciones en Visual Basic 2008

143

Tipos sin Signo Aparecen los tipos de dato ULong, UInteger y UShort, representando las clases sin signo de cada uno de los tipos de dato. Comentarios XML Esta es una opción que ya estaba disponible oficialmente en C# y ahora se incorpora a Visual Basic. Permite definir comentarios que serán de utilidad para la generación de la documentación oficial del proyecto. Un ejemplo de un comentario XML sería el siguiente (ubicándolo previo a la definición de un método). Además, esta información es utilizada por Intellisense para darle ayuda al cuando intenta utilizar el método:

VXPPDU\!

3URFHVDHOFOLFNGHXQXVXDULRHQHOERWyQ

VXPPDU\! ''' <param name="strNombre">Nombre del Boton

UHWXUQV!'HYXHOYHVLHVFRUUHFWRUHWXUQV!

Instrucción using Permite definir un bloque de código que utilizará algún objeto que queramos liberar al finalizar dicho bloque. Por ejemplo, las conexiones a bases de datos y la apertura de archivos o gráficos requieren de la apertura y liberación de recursos y son candidatos a usar esta instrucción. 8VLQJFRQH[LRQDV6TO&RQQHFWLRQ

$TXtYDHOFyGLJRTXHWUDEDMDFRQODFRQH[LyQ (QGXVLQJ

Operador TryCast Permite hacer un cast (moldeado) de un objeto hacia otra clase, pero que tiene la particularidad de devolver Nothing en caso de que el casting no se haya podido ejecutar. 'LPFDV&XDGUDGR 7U\&DVW¿JXUD&XDGUDGR

Incorporaciones en Visual Basic 2008 Nullable Types Si bien estaban disponibles desde Visual Basic 2005 utilizando genéricos, los tipos anulables, o Nullable Types, son tipos de datos que podemos permitirles ser nulos y que, hasta ahora, no tenían la posibilidad de serlo. Visual Studio - Firtman, Natale

Alfaomega

144


Por ejemplo, un entero no tenía forma de tener un valor nulo. Esto es muy importante para unir datos con bases de datos, dado que allí sí pueden existir campos con datos nulos. Desde VB 9 la sintaxis se volvió bastante simple; sólo se ingresa un símbolo ? –abreviatura del genérico 1XOODEOH2IWLSR ± al final del tipo de datos que se ha de utilizar: 'LP1XPHUR$V,QWHJHU" ,I1XPHUR+DV9DOXH7KHQ 7LHQHXQYDORU End If

La propiedad +DV9DOXH de cualquier tipo anulable devuelve tenga o no valor ingresado y *HW9DOXH2U'HIDXOW devuelve el valor o, si es nulo, un valor ingresado por parámetro.

Operador Ternario El operador ternario es un clásico de la programación en lenguajes derivados de C, como C# o Java. Desde Visual Basic 2008 también podremos utilizarlos con la siguiente sintaxis: 9DULDEOH ,IFRQGLFLRQYDORUGHUHWRUQRSRU7UXHB valor de retorno por False)

Esto nos permite evaluar una condición y devolver un valor u otro, según esta condición, evitando un clásico If a través de una expresión. Si bien VB tenía la función global IIf, en este último caso necesitábamos convertir el tipo de datos devueltos previamente.

Tipos Implícitos La nueva inclusión de tipos implícitos en Visual Basic, a partir de la instrucción Dim, nos va a permitir trabajar con variables cuyo tipo no es definido explícitamente –tal como lo hacíamos hasta ahora–, sino que el compilador será el responsable de deducir el tipo de la misma en función de lo que hayamos definido en el lado derecho de la inicialización. Así definíamos nuestras variables:

Alfaomega



145

$VLJQDFLyQH[SOtFLWD Dim valor As Integer = 1 Dim nombre As String = "Leonardo" 'LPQXPHUR$V6LQJOH ) 'LPDUU3URYLQFLDV$V$UUD\ 1HZ6WULQJ ^&DWDOXQLDB "Madrid", "Galicia"}

El mismo ejemplo con tipos implícitos:

$VLJQDFLyQLPSOtFLWD Dim valor = 1 Dim nombre = "Leonardo" 'LPQXPHUR ) 'LPDUU3URYLQFLDV 1HZ6WULQJ ^&DWDOXQLD0DGULG*DOLFLD`

El compilador deduce los tipos que no especificamos al utilizar la instrucción Dim. No hay que confundir la misma expresión en anteriores versiones de Visual Basic, donde el código también podía funcionar con Option Strict desactivado, pero redundaba en cuatro objetos de clase Object. Ahora, a los fines de compilación equivale a haberle definido explícitamente el tipo. La nueva opción Option Infer permite desactivar la inferencia de tipos y trabajar con el viejo modelo, aunque no es recomendable. Supongamos que definimos una variable, que implícitamente es del tipo Single, y luego le asignamos un texto; al momento de compilar obtendríamos un error: Dim miVariable = 4.8F PL9DULDEOH &XDOTXLHUWH[WR (UURU

Debido a que miVariable es del tipo Single, el compilador nos devolvería un error informándonos que, correctamente, no puede convertir un tipo String a Single. Otras cuestiones para tener en cuenta: s

Siempre debemos inicializar las variables: 'LPPL9DULDEOH 1RSXHGHLQIHULUHOWLSR

s

Dada la restricción anterior, se deben inicializar en la misma instrucción: Dim miVariable miVariable 1RSXHGHLQIHULUHOWLSR

s

No pueden establecerse como nulos: 'LPPL9DULDEOH 1RWKLQJ 1RSXHGHLQIHULUHOWLSR


Alfaomega

146


Inicializadores de objetos Una nueva funcionalidad ha sido agregada para ayudarnos al momento de tener que asignar un valor a campos, o propiedades accesibles, cuando creamos un objeto. Miremos como hacíamos antes para pasar algunos valores: &ODVV3URGXFWR 3XEOLF6XE1HZ (QG6XE Private _codigo As Integer Private _nombre As String Private _almacen As String 3XEOLF3URSHUW\&RGLJR $V,QWHJHU Get 5HWXUQBFRGLJR End Get 6HW%\9DOYDOXH$V,QWHJHU BFRGLJR YDOXH End Set End Property 3XEOLF3URSHUW\1RPEUH $V6WULQJ Get 5HWXUQBQRPEUH End Get 6HW%\9DOYDOXH$V6WULQJ BQRPEUH YDOXH End Set End Property 3XEOLF3URSHUW\$OPDFHQ $V6WULQJ Get 5HWXUQBDOPDFHQ End Get 6HW%\9DOYDOXH$V6WULQJ BDOPDFHQ YDOXH End Set End Property End Class 'LPSURG$V1HZ3URGXFWR

$VLJQDPRVXQYDORUDFDGDSURSLHGDG prod.Codigo = 3005 prod.Nombre = "Aceite Vegetal" prod.Almacen = "Madrid"

Alfaomega



147

Console.WriteLine("Código: " + prod.Codigo) Console.WriteLine("Nombre: " + prod.Nombre) Console.WriteLine("Almacen: " + prod.Almacen) Console.Read()

Otra forma sería pasando los valores por parámetro en el constructor: &ODVV3URGXFWR 3XEOLF6XE1HZ (QG6XE 3XEOLF6XE1HZ%\9DOFRGLJR$V,QWHJHU%\9DOQRPEUH$VB String) Me.Codigo = codigo Me.Nombre = nombre (QG6XE Private _codigo As Integer Private _nombre As String Private _almacen As String 3XEOLF3URSHUW\&RGLJR $V,QWHJHU Get 5HWXUQBFRGLJR End Get 6HW%\9DOYDOXH$V,QWHJHU BFRGLJR YDOXH End Set End Property 3XEOLF3URSHUW\1RPEUH $V6WULQJ Get 5HWXUQBQRPEUH End Get 6HW%\9DOYDOXH$V6WULQJ BQRPEUH YDOXH End Set End Property 3XEOLF3URSHUW\$OPDFHQ $V6WULQJ Get 5HWXUQBDOPDFHQ End Get 6HW%\9DOYDOXH$V6WULQJ BDOPDFHQ YDOXH End Set End Property End Class


Alfaomega

148


'LPSURG$V1HZ3URGXFWR$FHLWH9HJHWDO prod.Almacen = "Madrid" Console.WriteLine("Código: " + prod.Codigo) Console.WriteLine("Nombre: " + prod.Nombre) Console.WriteLine("Almacen: " + prod.Almacen) Console.Read()

Hasta aquí nada nuevo. Lo interesante es que, mediante inicializadores de objetos, vamos a poder definir nuestros valores en una misma instancia creacional sin tener que invocar a su método en forma explícita, permitiéndonos escribir líneas mucho más claras. Reutilizando el ejemplo anterior, su uso quedaría así: 'LPSURG$V1HZ3URGXFWR:LWK^1RPEUH $FHLWH9HJHWDOB .Almacen = "Madrid"}

¿Qué ventajas tenemos? En primer lugar, no necesitamos definir un constructor con parámetros. Por otro lado, podemos definir la cantidad de propiedades que se han de inicializar en cada momento y elegir el orden y cuáles vamos a definir. Por último, la instrucción With forma parte de una misma instrucción, por lo que puede ser utilizada en cualquier lugar donde pueda ir una expresión, como un 5HWXUQ o el envío de un parámetro sin necesidad de generar auxiliares. Trabajando con colecciones En C#, lenguaje donde también se han creado los inicializadores de objetos, existen los inicializadores de colecciones. Dicha posibilidad todavía no está disponible en Visual Basic, pero se podría emular fácilmente con la siguiente función: )XQFWLRQ&UHDU&ROHFFLRQ2I7 %\9DO3DUDP$UUD\LWHPV $V7 $VB List(Of T) 5HWXUQ1HZ/LVW2I7 LWHPV (QG)XQFWLRQ

Entonces, inicializamos listas de la siguiente manera: Dim lista = CrearColeccion( 1HZ3URGXFWR:LWK^1RPEUH $FHLWH9HJHWDO` 1HZ3URGXFWR:LWK^1RPEUH $FHLWXQDV` )

No obstante, los inicializadores de colecciones de C# son más potentes que nuestra simple función y esperamos tenerlos próximamente en Visual Basic. Alfaomega



149

Tipos Anónimos Ahora que hemos visto cómo funcionan los tipos implícitos y los inicializadores de objetos, vamos a estudiar otra nueva característica de Visual Basic 2008: Los tipos anónimos, que se basan principalmente en las dos características anteriores. Esta nueva característica nos va a permitir crear propiedades de modo implícito y asignarles un valor, pero que serán de sólo lectura. Básicamente, el compilador crea una clase del tipo anónimo con propiedades de un tipo que él va a inferir en función de nuestra declaración. Pero veamos un ejemplo sencillo: 'LPPRYLO 1HZ:LWK^0DUFD 1RNLD0RGHOR 1`

Notemos el uso de las palabras New With. ¿Nos es familiar, no? Claro que sí, estamos utilizando por un lados tipo anónimos y luego los inicializadores de objetos para asignarles valores a propiedades. ¿Pero si nunca creamos una clase con esas propiedades? Son propiedades que serán generadas por el compilador on the fly. Y es posible notar que en el código anterior nunca creamos explícitamente ni una clase, ni un tipo de propiedad, ni el nombre de la misma, así como tampoco sus s (Set y Get). Por cada objeto que creamos así se crea un tipo anónimo al compilar. El mismo es codificado en función del orden de las propiedades, sus tipos y cantidades que hayamos definido. Por deducción podemos afirmar que cuando se altere alguna de estas condiciones, el compilador de VB generará n clases de n tipos, según lo considere.

Fig. 4-4. Visual Studio nos provee de ayuda en Intellisense para las propiedades de nuestros tipos anónimos.

Métodos extensores Los métodos extensores nos brindarán la posibilidad de agregar métodos a tipos existentes, sin tener que derivar de ellos o modificar su implementación original. Muchas veces esto último no es posible, dado que quizá estemos interesados en Visual Studio - Firtman, Natale

Alfaomega

150


expandir las funcionalidades de un tipo del .NET Framework o de componentes de terceros. Crear métodos extensores es tan sencillo y fácil como crear cualquier otro método de instancia, pero con algunas pequeñas diferencias que deben tenerse en cuenta: s

Deben estar en un módulo.

s

Debe ser un 6XE o )XQFWLRQ

s

Deben tener al menos un parámetro.

s

La firma del método debe incluir el atributo Extension del espacio de nombres 6\VWHP5XQWLPH&RPSLOHU6HUYLFHV

s

El primer parámetro del método debe ser el tipo al que vamos a extender.

s

Cuando se ejecute, el primer parámetro pasa a ser la instancia del objeto.

Veamos un ejemplo simple, donde vamos a extender el tipo String: ,PSRUWV6\VWHP5XQWLPH&RPSLOHU6HUYLFHV 0RGXOH([WHQVRUHV <Extension()> _ 3XEOLF)XQFWLRQ7LHQH1XPHUR%\9DO[$V6WULQJ $V%RROHDQ 'LPUHJXODU([$V1HZ5HJH[>@ ,IUHJXODU([,V0DWFK[ 7KHQ 5HWXUQ7UXH End If 5HWXUQ)DOVH (QG)XQFWLRQ (QG0RGXOH

Básicamente, lo que hacemos es generar nuestro módulo Extensores y nuestro método 7LHQH1XPHUR. El objetivo de 7LHQH1XPHUR es devolver un tipo booleano, evaluando si la cadena de texto que se le envía como parámetro posee o no algún carácter comprendido entre 0 y 9. Notemos cómo el primer parámetro (x) define el tipo que queremos extender, en nuestro caso String. En el siguiente bloque de código, vemos cómo lo utilizamos: ' Importamos el espacio de nombres Imports MiApp.Extensores; 0RGXOH8VR0HWRGRV([WHQVRUHV

Alfaomega



151

6XE0DLQ 'H¿QLPRVDOJXQDVFDGHQDVGHSUXHED 'LPVWU3UXHED&RQ1XPHURV $EFG(I*+,-N 'LPVWU3UXHED6LQ1XPHURV $EFG(I*+,-N &RQVROH:ULWH/LQHVWU3UXHED&RQ1XPHURV7LHQH1XPHUR &RQVROH:ULWH/LQHVWU3UXHED6LQ1XPHURV7LHQH1XPHUR &RQVROH:ULWH/LQH3GVMNG'7LHQH1XPHUR Console.Read() (QG6XE (QG0RGXOH

Si ejecutamos este ejemplo, la respuesta sería: 7UXH False 7UXH

En la figura 4-5 podemos ver cómo el IntelliSense nos muestra el nuevo método estático generado y cómo lo distinguimos mediante un ícono nuevo.

Fig. 4-5. Métodos extensores definidos y su integración con el IntelliSense.

Es importante aclarar que no debemos hacer un mal uso de los métodos extensores; verifiquemos primero si no disponemos de la funcionalidad que estamos buscando, ya implementada de forma original. Por ejemplo, no tendría sentido que agreguemos uno de estos métodos a String con la finalidad de retornar una cadena en mayúsculas, dado que ya se encuentra desarrollada: String.ToUpper. Visual Studio - Firtman, Natale

Alfaomega

152


De todas formas, imaginemos por un momento que extendemos el tipo String con un método llamado Replace, que recibe dos parámetros –uno es un char que contiene el carácter que ha de ser reemplazado y el segundo es otro char con el dígito con el cual reemplazaremos– y, cuando vamos a utilizar este nuevo método, nos encontramos con que no está. El problema reside en que ya existe uno con ese nombre. Sin embargo, el problema real es que posee la misma firma. Lo que ocurre es que en un ámbito de trabajo, tiene mayor inferencia un método de instancia que un método extensor. Pero si de todas formas quisiéramos trabajar con el método extensor, podríamos llamarlo a través de su instancia estática como cualquier método. Ocurre algo parecido con los espacios de nombre, dado que los nombres de métodos extensores de espacios de menor profundidad poseen precedencia sobre los de mayor profundidad.

Expresiones Lambda Ahora que hemos visto las principales novedades y características de Visual Basic 2005 y 2008, quizá se torne complicado mostrar algunos ejemplos, en lo que resta de este capítulo, sin tener que mencionar LINQ, el cual será tratado más adelante. Dicho esto, nos adentraremos en los dos últimos temas: Expresiones Lambda y expresiones de consulta. Abordemos primero el tema de las expresiones Lambda: Éstas fueron incorporadas en Visual Basic 2008 y nos van a permitir trabajar con delegados y métodos anónimos de una forma diferente a la que habíamos observado hasta ahora. Avanzaremos de a poco, para que su entendimiento sea lo más claro posible, e iremos aportando mayor complejidad a medida que comprendamos los conceptos. La sintaxis, a grandes rasgos, es )XQFWLRQSDUiPHWURV H[SUHVLyQ. Citamos el siguiente ejemplo, utilizando una expresión lambda, para calcular el área de un círculo: 'LPDUHD )XQFWLRQ%\9DOUDGLR$V'RXEOH 0DWK3, UDGLR UDGLR

Entonces, para usar la expresión hacemos: &RQVROH:ULWH/LQH(OiUHDGHXQFtUFXORGHGHUDGLRHVGHB + area(10))

El mundo de las expresiones Lambda es un poco más complejo y, en general, para su uso se utiliza más C# . No obstante, Visual Basic provee de la sintaxis para la mayoría de los casos y recomendamos la lectura del capítulo anterior para interiorizarse en este tema. Alfaomega



153

Métodos Parciales Los métodos parciales permiten definir un prototipo de método, pero que podrá o no implementarse en la clase. No debe confundirse con la herencia o con una interface, dado que los métodos parciales son una implementación de precompilador. Si el compilador detecta que el método parcial se definió, pero no se implementó en ningún archivo de la clase (recordemos el concepto de clases parciales anteriormente visto), entonces elimina todas las llamadas a ese método, como si nunca hubieran existido. Si, en cambio, el método se definió, entonces se deja la invocación. Recordemos que hablamos siempre de la misma clase y no de la herencia o polimorfismo. ¿Qué objetivo tienen los métodos parciales? Pueden ser útiles para métodos de depuración de código, para evitar utilizar interfaces y obligar a un a implementar métodos vacíos y se utiliza para algunos de los nuevos frameworks, como ser el LINQ T o SQL, que luego veremos con más detenimiento en este libro. El método sólo puede ser de tipo 6XE, debe incluir la cláusula Partial en su prototipo y no incluir ninguna cláusula en la implementación, si es que existiera; deben ser privados y pueden ser de instancia o de clase (Shared). En un archivo podemos tener: Partial Class Clase1 3XEOLF3DUWLDO6XE'HEXJ%\9DO7[W$V6WULQJ (QG6XE End Class

Y, opcionalmente, en otro archivo parcial de la misma clase podría estar la implementación: Partial Class Clase1 3XEOLF6XE'HEXJ%\9DO7[W$V6WULQJ ' Codigo a implementar (QG6XE End Class

Cualquiera de las llamadas a ese método existirá en el compilado solamente si el método fue implementado. Si no, se evitan y no se compilan.

Literales XML Uno de los grandes agregados de Visual Basic 2008, incluso de uso más sencillo que en C#, son los literales XML: Una simple y poderosa forma de definir elementos XML que podrán potenciarse más con LINQ. Visual Studio - Firtman, Natale

Alfaomega

154


Literal de elemento XML Para crear un elemento XML sólo debemos hacer: 'LPFXUVR$V;(OHPHQW B FXUVR! <nombre>Experto en ASP.NET 3.5 GXUDFLRQW\SH PHVHV!GXUDFLRQ! <Web pais="AR">www.itmaster.com.ar <Web pais="ES">www.itmaster.es :HESDLV 0;!ZZZLWPDVWHUFRPP[:HE! FXUVR!

Notemos que para definir el objeto de clase ;(OHPHQW, sólo necesitamos escribir el XML, sin comillas, sin instanciar ningún objeto, ni nada más complejo. Visual Studio reconocerá que se trata de un XML y lo tratará como tal, tabulando correctamente y dando los colores correctos a este tipo de documento. Notemos también que, una vez iniciado un literal XML, no necesitamos colocar el carácter de continuación de línea de Visual Basic ( _ ) hasta tanto finalice el XML válido. Literal de Documento XML El código anterior representa a un nodo XML de clase ;(OHPHQW. Si lo que queremos es crear un documento XML (que incluya cabecera, una posible transformación XSLT, nodos y otros atributos), el paso es similar pero utilizando ;'RFXPHQW: 'LP/LVWDGR&XUVRV$V;'RFXPHQW B FXUVRV! FXUVR! <nombre>Experto en ASP.NET 3.5 GXUDFLRQW\SH PHVHV!GXUDFLRQ! <Web pais="AR">www.itmaster.com.ar <Web pais="ES">www.itmaster.es :HESDLV 0;!ZZZLWPDVWHUFRPP[:HE! FXUVR! FXUVRV!

La clase ;'RFXPHQW tiene decenas de métodos útiles, como ser Load o Save, que permiten crear y guardar el XML desde y hacia archivos, URLs, strings y clases. La clase se encuentra en el espacio de nombres 6\VWHP;PO/LQT y recomendamos ampliamente revisar sus posibilidades desde MSDN o con la ayuda de Visual Studio.

Alfaomega



155

Expresiones Incrustadas Las expresiones incrustadas permiten incluir en el literal XML expresiones Visual Basic válidas, en lugar de solamente valores constantes. Por ejemplo: Dim URL = "www.itmaster" 'LPFXUVR$V;(OHPHQW B FXUVR! <nombre>Experto en ASP.NET 3.5 GXUDFLRQW\SH PHVHV!GXUDFLRQ! <Web pais="AR"><%= URL %>.com.ar <Web pais="ES"><%= URL %>.es :HESDLV 0;! 85/!FRPP[:HE! FXUVR!

Las expresiones incrustadas se pueden utilizar en el nombre de una etiqueta (donde se espera un objeto ;1DPH), en el nombre de un atributo (;1DPH), en valor de un atributo (cualquier objeto) o en el texto interior de un nodo (cualquier objeto). También se puede incrustar directamente un objeto ;$WWULEXWH, representando un atributo y su valor, o un ;(OHPHQW, representando el nodo raíz. Esto nos evita tener que generar nodos auxiliares o crearlos vacíos e ir incorporándoles contenido dinámico línea por línea. Con estas expresiones, rápidamente creamos contenido dinámico dentro de un archivo XML. Las expresiones incrustadas se pueden mezclar con expresiones LINQ, que nos permitirán, por ejemplo, insertar n cantidad de subnodos según alguna colección. Por ahora, sólo veremos un ejemplo rápido para comprender la idea. Supongamos que tenemos una lista de objetos, de clase Unidad Temática, cada uno con la propiedad Nombre: 'LPFXUVR B FXUVR! <nombre>Experto en ASP.NET 3.5 GXUDFLRQW\SH PHVHV!GXUDFLRQ! XQLGDGHV! <%= From Unidad In ListaUnidades _ 6HOHFWXQLGDG! 8QLGDG1RPEUH!XQLGDG!B %> XQLGDGHV! FXUVR!

Expresiones de consulta Las expresiones de consulta poseen su pilar en todo lo visto anteriormente, es por eso que lo hemos dejado para el final. Aquí utilizaremos expresiones Lambda, inicializadores de objetos, métodos extensores y mucho más. Como no podía Visual Studio - Firtman, Natale

Alfaomega

156


ser de otra manera, este tema está íntimamente ligado con LINQ, dado que es la herramienta que utilizaremos para nuestras consultas más adelante. Las expresiones de consulta nos van a permitir recuperar uno o más orígenes de datos y valores, mediante una serie de instrucciones que luego manipularemos en nuestra aplicación. El resultado obtenido puede ser, además, una fuente de datos para otra consulta. Quienes trabajen con lenguajes SQL notarán una gran similitud con ellos, aunque con algunas diferencias. Pero es importante destacar la posibilidad de realizar portabilidad de conocimientos, dado que nos ahorrará tiempos de aprendizaje y adopción de este tipo de búsquedas. La primera diferencia que encontramos es que comienzan con la cláusula From en lugar de la clásica Select, ubicándose ésta al final de la expresión. Para que podamos escribir nuestras consultas, el origen de los datos debe implementar ,(QXPHUDEOH2I7 o ,4XHU\DEOH2I7 . Veamos un ejemplo simple: 'LP$UU3DLVHV$V6WULQJ ^$UJHQWLQD8UXJXD\B "Alemania", "Canada", "Colombia"} Dim VarPaises = From Pais In ArrPaises _ Where Pais.StartsWith("A") _ Order By Pais Descending _ Select Pais For Each Pais As String In VarPaises Console.WriteLine("Pais: " & Pais) Next Console.Read()

Resultando: Pais: Argentina Pais: Alemania

Lo primero que hacemos es declarar una variable (VarPaises) que contiene el resultado de nuestra consulta y que, además, cumple con la interface ,(QXPHUDEOH2I7 , para luego poder recorrer y obtener los valores esperados. Luego, comenzaremos a escribir nuestra expresión: Seguido de From especificamos una variable, denominada variable de rango, que infiere el tipo de dato –en este caso 6WULQJ± del contexto actual. Utilizamos In para declarar cuál es nuestra colección que contiene los datos que serán evaluados. Notemos cómo hemos utilizado in para filtrar el origen mediante la cláusula Where. Alfaomega



157

En este caso, vamos a obtener todos los países de $UU3DLVHV>@ que comiencen con la letra A y especificaremos, también, que el resultado esté ordenado (mediante Order By … Descending) en forma descendente. Supongamos otro caso. Pensemos que tenemos nuestra clase Cliente con tres propiedades: Código, Denominación y Provincia. Y necesitamos obtener todos los clientes cuyo código de identificación es mayor que 89. Observemos el siguiente bloque de código para ver cómo podríamos hacerlo: Class Cliente Private _Codigo As Integer 3XEOLF3URSHUW\&RGLJR $V,QWHJHU Get 5HWXUQB&RGLJR End Get 6HW%\9DOYDOXH$V,QWHJHU B&RGLJR YDOXH End Set End Property Private _Denominacion As String 3XEOLF3URSHUW\'HQRPLQDFLRQ $V6WULQJ Get 5HWXUQB'HQRPLQDFLRQ End Get 6HW%\9DOYDOXH$V6WULQJ B'HQRPLQDFLRQ YDOXH End Set End Property Private _Provincia As String 3XEOLF3URSHUW\3URYLQFLD $V6WULQJ Get 5HWXUQB3URYLQFLD End Get 6HW%\9DOYDOXH$V6WULQJ B3URYLQFLD YDOXH End Set End Property End Class Dim clientes As New List(Of Cliente) clientes.Add(New Cliente With {.Codigo=100,_ Denominacion="Pablo Ferreyra"}) clientes.Add(New Cliente With {.Codigo=102,_ Denominacion="Gabriel Martinez"}) clientes.Add(New Cliente With {.Codigo=92,_ 'HQRPLQDFLRQ 0DULD$U]XHJD` Dim listClientes = From cli In clientes _ Where cli.Codigo > 90 _


Alfaomega

158


Select New With { _ .Nombre = cli.Nombre, .Codigo = cli.Codigo _ } For Each cliente In listClientes Console.WriteLine("Nombre: {0} Codigo: {1}",_ cliente.Nombre, cliente.Codigo) Next Console.Read()

Detengámonos en la definición de la consulta: ¿No notan algo extraño pero ya conocido? Sí, estamos utilizando tipos anónimos e inicializadores de objetos. Quizá lo que muchos se estarán preguntando es cómo se interpreta esta especie de código SQL para que pueda ser ejecutado. Básicamente, VB traduce las sentencias de consulta en invocaciones de métodos, de instancias o extensores, como por ejemplo Select, Where u OrderBy. Cada uno de ellos responde a un patrón de consultas y, mediante un mapeo entre sentencia-método, saben cómo deben procesar cada una de las instrucciones que hemos escrito. De hecho, podemos escribir nuestras consultas en notación de métodos y que para muchos resulte más fácil o entendible hacerlo de esta manera. Tenemos más opciones para escribir nuestras consultas, pero vamos a esperar al capítulo de LINQ para estudiarlas con detenimiento.

Alfaomega


Qué es

LINQ

159

5

Qué es LINQ es una nueva metodología para escribir consultas embebidas en nuestro código, de ahí su denominación: El acrónimo LINQ significa Consulta Integrada en el Lenguaje (en inglés, Language Integrated Query). El poder de LINQ está basado en todas las nuevas características que fueron incorporadas en los Frameworks 3.0 y 3.5 y en las últimas versiones de los lenguajes que vimos en capítulos anteriores. Con ejemplos sucesivos podremos comprender cómo LINQ agrega y extiende la funcionalidad de los lenguajes del .NET Framework. A lo largo de este capítulo iremos analizando los diversos espacios de nombres que tenemos, su sintaxis y cómo trabajar con LINQ.

Por qué se lo necesita Muchas veces cuando trabajamos sobre un proyecto tenemos que obtener y procesar información de diversas fuentes de datos, como por ejemplo un archivo XML, una colección de objetos en memoria o una base de datos. Para lograr ello utilizamos, dependiendo de cuál sea el origen de los datos, diferentes lenguajes. Cuando necesitamos consultar una tabla de una base de datos Microsoft SQL Server, escribimos nuestras consultas en T-SQL en nuestra capa de a datos para obtener, por ejemplo, un DataSet y luego procesarlo según nuestra necesidad. Visual Studio - Firtman, Natale

Alfaomega

160

5- Linq

Hay veces en las que trabajar con archivos XML se torna un poco molesto y siempre pensamos o esperamos alguna solución un poco más práctica, en lugar de tener que emplear XPath o XQuery. LINQ nos habilitará para escribir consultas independientemente de la fuente de información, manipulando el resultado de forma holgada y eficiente, proveyéndonos de una capa de abstracción extremadamente útil. Con LINQ podremos aprovechar todo el potencial de Visual Studio gracias al IntelliSense, que es un soporte para hacer depuración y verificación de errores en tiempo de compilación sobre cualquier origen de datos. En este capítulo repasaremos los principales proveedores de LINQ: s

LINQ a Objetos.

s

LINQ a XML.

s

LINQ a SQL.

s

LINQ a Dataset.

En la figura 5-1 podemos ver un esquema bastante ilustrativo de LINQ.

Fig. 5-1. Esquema de LINQ con lenguajes y expresiones.

En el día a día cuando trabajamos con consultas, inconscientes o no, hacemos una pequeña receta, de forma casi involuntaria: s

Determinamos cuál es la fuente de datos (un archivo, una base de datos).

s

Escribimos nuestra consulta que filtrará y modelará los datos.

Alfaomega


Sintaxis

s

161

Obtenemos el resultado y hacemos algo con ellos, por ejemplo asignarlos como un datasource de un componente para su representación gráfica.

Lo interesante es que utilizar LINQ no escapa a este pequeño listado y lo podemos aplicar a cualquier fuente de datos.

Sintaxis Para escribir nuestras consultas en LINQ utilizaremos muchos de los conocimientos estudiados sobre los lenguajes C# y VB. En los capítulos 3 y 4 vimos lo que son las expresiones de consulta, una manera de escribir muy similar al lenguaje SQL. Ésta no es la única forma, tenemos también la posibilidad de realizarlas mediante llamadas a métodos y, de hecho, en muchas circunstancias las tendremos que hacer con ellas, dado que no siempre podremos obtener de forma rápida y sin tanto código el dato que necesitamos mediante las expresiones de consulta.

Sintaxis de métodos Los operadores de consultas estándar son métodos (se encuentran dentro del espacio de nombres System.Linq) que nos van a ampliar el espectro de funcionalidades comparados con las expresiones de consulta, brindándonos la posibilidad de realizar operaciones como agregaciones, filtrados y ordenamiento, entre otros. Muchos de ellos tienen su representación en expresiones de consulta, como por ejemplo select u orderby, aunque como contracara hay métodos, como Average, que no poseen su mapeado en expresiones de consulta. Escribir consultas a fuentes de datos como expresiones de métodos no va a implicar una mejora de rendimiento, pero sí de usabilidad y de escalabilidad. Generalmente se recomienda escribirlas como expresiones de consulta, dado que son más fáciles de leer. Éstos poseen funcionalidad sobre objetos que implementan las interfaces IEnumerable e IQueryable , definiéndose como métodos de extensión. Lo interesante es que podemos anidarlos sobre una misma consulta para lograr profundidad y complejidad, donde el resultado del primer orden de la secuencia es la entrada para el segundo orden y así sucesivamente. Veamos un ejemplo con expresiones de consulta en C# y Visual Basic y el mismo pero hecho mediante métodos:


Alfaomega

162

5- Linq

int[] arrInts = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; // Como expresión de consulta var resultInts = from n in arrInts where n > 2 && n < 8 select n; // Mediante métodos var resultInts2 = arrInts .Where(n => n > 2 && n <8 ) .Select(n=>n);

Dim arrInts As Integer() = {1, 2, 3, 4, 5, 6, _ 7, 8, 9} ‘ Como expresión de consulta Dim resultInts = From n In arrInts _ Where n > 2 AndAlso n < 8 _ Select n ‘ Mediante métodos Dim resultInts2 = arrInts.Where(Function(n) n > 2 AndAlso n < 8).Select(Function(n) n)

Ahora supongamos que deseamos obtener la suma de todos los números del arreglo; utilizando métodos, podríamos escribirlo en tan solo una línea: var resultInts3 = arrInts.Sum(); Dim resultInts3 = arrInts.Sum()

Sum es un método extensor que calculará la suma de todos los números que tenemos en la colección arrInts. En la figura 5-2 podemos apreciar las diferentes opciones que nos propone el IntelliSense. A partir de ahora, en este capítulo utilizaremos sintaxis en C# y, en algunos casos, aclararemos diferencias con Visual Basic; pero más allá de las diferencias clásicas entre ambos lenguajes, las consultas LINQ son casi idénticas entre ambos.

Alfaomega


Sintaxis

163

Fig. 5-2. Funcionalidades al trabajar con consultas de sintaxis de métodos.

En la siguiente tabla observamos algunos de los métodos más usados: Método

Descripción

Average()

Calcula el promedio de una secuencia de valores.

Count()

Devuelve la cantidad de elementos en la colección.

Sum()

Calcula la suma de los elementos de la secuencia.

Max()

Retorna el valor máximo

Min()

Retorna el valor mínimo.

Skip()

Devuelve los elementos posteriores de una secuencia cuya posición es superior a n.

ToArray()

Crea una matriz a partir de un objeto IEnumerable .

Union()

Proporciona la unión de elementos de dos secuencias

Where()

Filtra los valores de los elementos en función de un predicado.

Sintaxis de Consulta Repasando los capítulos anteriores, la sintaxis de consulta nos permite ejecutar LINQ de manera más simple y legible que con la sintaxis de método. La sintaxis de consulta comienza con el operador from, indicando el origen de datos, y una variable que hace los efectos de elemento de prueba sobre la colección origen y,


Alfaomega

164

5- Linq

como mínimo obligatorio, una sentencia select indicando el formato de salida de nuestra consulta. Así, la expresión de consulta LINQ más simple tendría la siguiente forma: // En C# var resultado = from o in origen select o; ‘ En Visual Basic Dim resultado = From o In Origen Select o;

La consulta anterior nos entrega exactamente la misma colección origen sin cambios. Siempre empezaremos una consulta con el operador from y la terminaremos con select.

Operadores Operadores de selección También son llamados operadores de proyección. Permiten definir una salida en particular respecto de la fuente de datos y otros operadores que hayan afectado a la consulta. El operador más utilizado es Select, que indica el formato de salida. Veamos algunos ejemplos de uso: 'H¿QLPRVXQDOLVWDGHHMHPSOR var Lista = new List (); // Devolviendo la misma colección de origen var resultado = from Elemento in Lista select Elemento; // Devolviendo solo un atributo de la colección var resultado = from Elemento in Lista select Elemento.Atributo // Devolviendo una transformación sobre un atributo de la colección var resultado = from Elemento in Lista select Transformacion(Elemento.Atributo); // Creando un tipo anónimo para devolver más atributos // pero no todos var resultado = from Elemento in Lista select new {Elemento.Atributo1, Elemento.Atributo2};

Alfaomega


Sintaxis

165

// Idem anterior, pero cambiando nombres var resultado = from Elemento in Lista select new {Id=Elemento.Atributo1, Nombre=Elemento.Atributo2} // Seleccionando de dos origenes. SelectMany var resultado = from e1 in Lista, e2 in Lista2 select new {e1, e2}

Operadores de Restricción El operador Where permite filtrar el origen de datos según una o más condiciones lógicas. 'HYROYLHQGRODPLVPDFROHFFLyQGHRULJHQ¿OWUDGD var resultado = from Elemento in Lista where condicion_logica select Elemento;

La condición lógica puede incluir expresiones combinadas con And (&&) u Or (!!) y, también, el uso de métodos del framework, supeditado a que el proveedor LINQ que estemos utilizando (objetos, XML, SQL, etc.) haya implementado ese método. Por ejemplo, podremos utilizar una sentencia del estilo para filtrar clientes por nombre: // Trae quienes comiencen con A, a o á var Consulta = from c in Clientes where c.ToUpper().StartsWith(“A”) || c.StartsWith(“á”) select c; // Trae quienes contengan S.A. var Consulta = from c in Clientes where c.Contains(“S.A.”) select c;

El equivalente en Visual Basic sería: ‘ Trae quienes comiencen con A, a o á Dim Consulta = From c In Clientes _ Where c.ToUpper().StartsWith(“A”) _ OrElse c.StartsWith(“á”) _ Select c


Alfaomega

166

5- Linq

‘ Trae quienes contengan S.A. Dim Consulta = From c In Clientes _ Where c.Contains(“S.A.”) _ Select c

Por ejemplo, si en el código anterior utilizamos LINQ To Objects, siendo Clientes una colección del .NET Framework, entonces se utilizarán los métodos de la clase String. Si Clientes fuera una colección traída desde una base de datos SQL a través de LINQ To SQL, el código anterior se traduciría en una sentencia SQL, utilizando funciones T-SQL para proveer de la funcionalidad (por ejemplo, el operador LIKE al utilizar Contains). Esta traducción a T-SQL se realiza de manera automática y eficiente por el proveedor LINQ, que viene ya incluido en el framework. Operadores de Ordenación Como su nombre lo indica, cambian el orden de salida de los elementos de la colección, que previamente pudo o no ser filtrada por una condición Where. El operador principal es OrderBy y aquí vemos algunos ejemplos: // Ordena por un atributo nombre ascendente, luego de // seleccionar los habilitados var Consulta = from c in Clientes where c.EstaHabilitado orderby c.Nombre select c; // Si el elemento de la colección es ordenable, se puede // utilizar directamente var Consulta = from c in Clientes orderby c select c; // Ordenamos descendiente var Consulta = from c in Clientes orderby c.Deuda descending select c; // Ordenamos por dos atributos var Consulta = from c in Clientes orderby c.FechaAlta descending, c.Nombre select c; 0LVPRHMHPSORDQWHULRUSHURXWLOL]DQGRVLQWD[LVGHPpWRGRV var Consulta = Clientes.OrderByDescending(c=>c.FechaAlta). ThenBy(c=>c.Nombre);

Alfaomega


Sintaxis

167

Y en Visual Basic: ‘ Ordena por un atributo nombre ascendente, luego de ‘ seleccionar los habilitados Dim Consulta = From c In Clientes _ Where c.EstaHabilitado _ Order By c.Nombre _ Select c ‘ Si el elemento de la colección es ordenable, se puede ‘ utilizar directamente Dim Consulta = From c In Clientes _ Order By c _ Select c ‘ Ordenamos descendiente Dim Consulta = From c In Clientes _ Order By c.Deuda Descending _ Select c ‘ Ordenamos por dos atributos Dim Consulta = From c In Clientes _ Order By c.FechaAlta Descending, c.Nombre _ Select c µ0LVPRHMHPSORDQWHULRUSHURXWLOL]DQGRVLQWD[LVGHPpWRGRV Dim Consulta = Clientes.OrderByDescending(Function(c) c.FechaAlta).ThenBy(Function(c) c.Nombre)

Operadores de Agrupación Permiten generar grupos de elementos a partir de una agrupación dada. Por ejemplo: string[] Paises = { “Argentina”, “Argelia”, “España”, “Estonia”, “Uruguay” }; var AgrupadosPorLetra = from p in Paises group p by p[0] into g select new { Letra = g.Key, Paises = g };

En el ejemplo anterior estaríamos generando una colección donde cada elemento posee un atributo letra, que será un carácter, y un atributo Paises, que será una colección de strings de los países que comienzan con esa letra. Los grupos pueden complicarse lo que uno desee.


Alfaomega

168

5- Linq

Operadores de Elemento Estos operadores se aplican sobre una colección o consulta LINQ y devuelven un elemento de dicha colección. Algunos de los operadores son: First, que devuelve el primer elemento; FirstOrDefault, que devuelve el primer elemento o, si no lo tuviera, el valor por defecto para el tipo de datos de la colección; ElementAt, que devuelve un elemento en particular por índice y Single, que devuelve el primer elemento y da una excepción si la colección tuviera más de uno. Operadores de Agregación Los operadores en esta categoría se aplican a una consulta completa y ofrecen alguna funcionalidad de cálculo sobre la lista. Los operadores son: Count, Sum, Min, Max, Average y Fold. Dado un maestro de clientes, queremos obtener el total de cada uno de ellos agrupados por país. Para ello utilizaremos el método extensor Count: class Cliente { public int Codigo { get; set; } public string Denominacion { get; set; } public string Pais { get; set; } } class Program { static void Main(string[] args) { List maestroClientes = new List { new Cliente {Codigo=501,Denominacion=”Carlos Mess”,Pais=”Colombia”}, new Cliente {Codigo=400,Denominacion=”Rodolfo Ibarra”,Pais=”Argentina”}, new Cliente {Codigo=874,Denominacion=”Carla Pietra”,Pais=”Chile”}, new Cliente {Codigo=372,Denominacion=”Lucia Galan”,Pais=”Colombia”}, new Cliente {Codigo=274,Denominacion=”Patricio Miguenz”,Pais=”Argentina”}, }; var resumenCli = from cli in maestroClientes orderby cli.Pais group cli by cli.Pais into clientes select new {Pais = clientes.Key, Cant = clientes.Count()};

Alfaomega


Sintaxis

169

foreach (var item in resumenCli) { Console.WriteLine(“Pais: {0} - Clientes: {1}”, item.Pais, item.Cant); } Console.Read(); } }

Operadores de concatenación Aquí vamos a ver cómo concatenar dos colecciones, mediante el método Concat, para luego concatenar una tercera. Es un ejemplo sencillo de anidación de métodos. string[] paisesNorte = {“Canada”,”EEUU”}; string[] paisesSur = {“Argentina”, “Chile”, “Uruguay”}; var paises = paisesNorte.Concat(paisesSur) .Concat(new[]{“Brasil”});

Resultado de este bloque de código: Pais: Pais: Pais: Pais: Pais: Pais:

Canada EEUU Argentina Chile Uruguay Brasil

Operadores de división Estos operadores permiten particionar o paginar la salida, ya sea por alguna condición fija (Take, Skip) o dinámica (TakeWhile, SkipWhile). Así, por ejemplo, si queremos los diez primeros elementos de una colección, podemos indicar: var Lista10 = Lista.Take(10);

Y si queremos los siguientes diez, entonces hacemos: var ListaSiguientes10 = Lista.Skip(10).Take(10);

TakeWhile podemos utilizarlo como una especie de corte de control, que nos habilitará para recorrer una colección hasta que se cumpla una condición (en este ejemplo, hasta que el código del cliente sea menor que 800). Visual Studio - Firtman, Natale

Alfaomega

170

5- Linq

List maestroClientes = new List { new Cliente {Codigo=501,Denominacion=”Carlos Mess”, Pais=”Colombia”}, new Cliente {Codigo=400,Denominacion=”Rodolfo Ibarra”, Pais=”Argentina”}, new Cliente {Codigo=874,Denominacion=”Carla Pietra”, Pais=”Chile”}, new Cliente {Codigo=372,Denominacion=”Lucia Galan”, Pais=”Colombia”}, new Cliente {Codigo=274,Denominacion=”Patricio Miguenz”, Pais=”Argentina”}, }; var misClientes = maestroClientes.TakeWhile(n => n.Codigo < 800);

El mismo ejemplo en Visual Basic nos quedaría: Dim maestroClientes As New List(Of Cliente) maestroClientes.Add(New Cliente With { .Codigo=501, .Denominacion=”Carlos Mess”, .Pais=”Colombia” }) ‘Resto de los clientes Dim misClientes = maestroClientes.TakeWhile(Function(n) n.Codigo < 800)

Operadores de Conjuntos Estos operadores permiten trabajar con operaciones de conjuntos matemáticos sobre dos colecciones de datos. Entre los operadores encontraremos Distinct (sin repeticiones), Union (unión), Intersect (intersección) y Except (excepción). En estas dos demostraciones, trabajaremos con dos listas cuyos elementos son marcas de autos. En el ejemplo 1, utilizaremos Union para obtener un conjunto de ambas colecciones sin duplicidad de elementos. En el segundo, mediante Intersect tendremos como resultado sólo los ítems que se encuentren tanto en la listaA como en la listaB. string[] listaA = { “Suabru”, “Honda”, “Audi”, “BMW” }; string[] listaB = { “Porsche”, “BMW”, “Ferrari”, “Honda” }; (MHPSOR var listaAB = listaA.Union(listaB);

Alfaomega


Sintaxis

171

(MHPSOR var listaAIntersecB = listaA.Intersect(listaB); foreach (var item in listaAB) { Console.WriteLine(“listaAUnionB - Marca: {0}”, item); } foreach (var item in listaAIntersecB) { Console.WriteLine(“listaAIntersecB - Marca: {0}”, item); } Console.Read();

Otros operadores Existen otros operadores que escapan al ámbito de este libro, tales como operadores de combinación (MRLQ), de igualdad, generacionales y de cuantificación, que tienen menos uso que los mencionados anteriormente. Se recomienda interiorizarnos y echarle un vistazo a todos los métodos que disponemos para sacar el mayor provecho a LINQ. Un buen punto de partida es el sitio de desarrolladores de Microsoft, el MSDN (msdn.microsoft.com).

Combinando las consultas A medida que construyamos consultas, nos vamos a dar cuenta de que sería bueno poder utilizar algunas características de expresiones de consulta y otras de expresiones de método en forma conjunta. Pues bien, eso es posible. Es decir que podremos utilizar todo el potencial de ambas para procesar una fuente de datos y obtener el resultado que esperamos. Retomando el ejemplo anterior, podríamos generar una consulta donde obtengamos la suma de todos los elementos de la colección arrInts mayores que 2 y menores que 8: int[] arrInts = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; var resultInts = (from n in arrInts where n > 2 && n < 8 select n).Sum(); Console.Write(resultInts);


Alfaomega

172

5- Linq

Notemos que, a diferencia de los ejemplos anteriores, estamos obteniendo un único valor, no una colección IEnumerable. Es por ello que no necesitamos escribir una instrucción foreach para poder imprimir la respuesta. Veamos el mismo ejemplo en VB: Dim arrInts As Integer() = {1, 2, 3, 4, 5, 6, _ 7, 8, 9} Dim resultInts = (From n In arrInts _ Where n > 2 AndAlso n < 8 _ Select n).Sum() Console.Write(resultInts)

Ejecución de consultas Es importante que entendamos en qué momento nuestras consultas son procesadas para obtener la información que deseamos. Muchas veces este concepto suele prestarse a confusión cuando trabajamos con LINQ, es por eso que en este apartado vamos a desmitificar algunas cuestiones. Para explicar cómo funcionan, utilicemos un ejemplo: List arrInt = new List { 2, 3, 4, 5, 6, 7, 8, 9 }; var resultInt = from n in arrInt where n > 5 select n; foreach (var item in resultInt) { Console.WriteLine(item); } Console.Read();

El código anterior dará como respuesta los números comprendidos entre 6 y 9, inclusive. Quizá, es posible presuponer que nuestra consulta será procesada cuando finalice la sentencia con el select n. La realidad es que no, simplemente lo que estamos haciendo es declarar una variable (resultInt) en memoria que contiene una suma de instrucciones, las cuales serán ejecutadas cuando recorramos la colección, es decir, cuando comencemos a ejecutar el bloque de código encabezado por foreach, solicitando el primer elemento. A esto se lo conoce como ejecución diferida. Tomando el ejemplo anterior, agreguemos ahora una línea para comprobar el funcionamiento de las ejecuciones diferidas:

Alfaomega


Sintaxis

173

List arrInt = new List { 2, 3, 4, 5, 6, 7, 8, 9 }; var resultInt = from n in arrInt where n > 5 select n; // Agregamos otros valores arrInt.AddRange(new[] {10, 20, 30, 40}); foreach (var item in resultInt) { Console.WriteLine(item); } Console.Read();

Lo que hicimos fue agregar cuatro valores más a la lista después de la representación de nuestra consulta. Si ejecutamos este código tendremos como salida los números comprendidos entre 6 y 9, inclusive, más los cuatro elementos que incorporamos. Esto nos va a permitir ir construyendo la consulta en diferentes etapas para luego ejecutarla, así como también la posibilidad de volver a utilizarla, dado que, como ya mencionamos, nuestra variable no contiene los datos, sino la sintaxis de la consulta. Deberemos tener cuidado cuando trabajamos con variables externas que pueden ser modificadas, dado que podrían causar una salida no esperada por nosotros (como vimos en el ejemplo anterior, que arrInt alteró el número de elementos de su colección). Observemos ahora otra pequeña modificación al ejemplo con el cual estamos trabajando: List arrInt = new List { 2, 3, 4, 5, 6, 7, 8, 9 }; var resultInt = (from n in arrInt where n > 5 select n).Sum(); Console.WriteLine(resultInt); Console.Read();

Aquí estamos forzando una ejecución inmediata, dado que, para poder realizar la suma, el método Sum debe iterar por todos los elementos resultantes de la consulta. Si por el contrario, necesitáramos ejecutar de forma inmediata nuestra consulta para tener en memoria los resultados como una colección, podríamos reemplazar Sum por ToList o ToArray: Visual Studio - Firtman, Natale

Alfaomega

174

5- Linq

List arrInt = new List {2, 3, 4, 5, 6, 7, 8, 9 }; var resultInt = (from n in arrInt where n > 5 select n).ToList(); foreach (var item in resultInt) { Console.WriteLine(item); } Console.Read();

Tipos de expresiones LINQ posee diversos proveedores para poder trabajar con diferentes fuentes de datos. Repasaremos los principales, analizando diferentes ejemplos y cómo lograr productividad en cada uno de los escenarios donde lo implementaremos.

LINQ a Objetos Una de las opciones que tenemos es utilizar objetos en memoria enumerables como fuentes de datos. De hecho, la mayoría de los ejemplos que vimos hasta aquí fueron realizados con LINQ a Objetos (LINQ to Objects). Mediante LINQ a Objetos podremos hacer consultas sobre objetos que implementen IEnumerable o su correspondiente interface no genérica, ya sean de tipos provistos por el .Net Framework o creadas por nosotros mismos. Por definición, cualquier colección que implemente la interface IEnumerable o IEnumerable se la denomina secuencia, es decir que si tenemos una lista del tipo Cliente, estaríamos ante la presencia de una secuencia de clientes. Tengamos en mente que estas secuencias luego pueden ser fuentes de datos para algún componente de un formulario Windows o un formulario Web, como veremos a continuación en algunos ejemplos. Ejemplo 1 Supongamos que tenemos un supermercado con dos depósitos, A y B, cada uno con productos segmentados por rubros, y queremos hacer una aplicación Windows que nos permita obtener un listado de artículos cuyo stock sea superior que cero en función del rubro seleccionado.

Alfaomega


Tipos de expresiones

175

Lo primero que haremos será generar un proyecto de aplicación de formularios Windows y dejaremos sus propiedades por defecto. Al formulario agregaremos los siguientes componentes: s

Dos Labels.

s

Un ListBox con la propiedad nombre: lstProductos (contendrá los productos).

s

Un ComboBox con la propiedad nombre: cmbRubro (aquí tendremos los rubros).

En la figura 5-3 podemos apreciar su distribución:

Fig. 5-3. Diseño del formulario Windows.

Agregaremos al proyecto una nueva clase, llamada Producto.cs, con tres propiedades que representarán el nombre, el rubro (al que pertenece el producto) y el stock: class Producto { public string Nombre { get; set; } public int Stock { get; set; } public string Rubro { get; set; } }

En la ventana de código de nuestro formulario, declararemos dos listas del tipo Producto que van a representar el inventario de cada depósito: Visual Studio - Firtman, Natale

Alfaomega

176

5- Linq

public partial class Form1 : Form { // Listado de productos de cada depósito List inventarioA, inventarioB; public Form1() { InitializeComponent(); } }

Crearemos un método ArmarInventarios(), donde poblaremos las listas con algunos datos de ejemplos: private void ArmarInventarios() { inventarioA = new List { new Producto{Nombre=”Aceite Girasol”, Rubro=”Aceites”,Stock=10}, new Producto{Nombre=”Mostaza”,Rubro=”Aderezos”, Stock=12}, new Producto{Nombre=”Aceite Oliva”, Rubro=”Aceites”,Stock=0}, new Producto{Nombre=”Mayonesa”,Rubro=”Aderezos”, Stock=56}, new Producto{Nombre=”Gaseeosa Cola”, Rubro=”Bebidas”,Stock=43}, new Producto{Nombre=”Agua sin gas”, Rubro=”Bebidas”,Stock=42}, }; inventarioB = new List { new Producto{Nombre=”Resma A4”, Rubro=”Librería”,Stock=23}, new Producto{Nombre=”Lápiz 2H”, Rubro=”Librería”,Stock=7}, new Producto{Nombre=”Jabón Neutro”, Rubro=”Limpieza”,Stock=91}, new Producto{Nombre=”Detergente”, Rubro=”Limpieza”,Stock=5}, new Producto{Nombre=”Leche”,Rubro=”Lácteos”, Stock=0}, new Producto{Nombre=”Agua sin gas”, Rubro=”Bebidas”,Stock=11}, new Producto{Nombre=”Queso”,Rubro=”Lácteos”, Stock=0}, }; }

Alfaomega



177

Este método será invocado desde el constructor de Form1.cs para tener los datos listos para realizar consultas. Primero necesitamos obtener una colección de rubros de ambos inventarios de los depósitos. Para ello, escribiremos el método ObtenerRubros, que tendrá como tipo de retorno un IEnumerable<string> donde codificaremos nuestra consulta LINQ: public IEnumerable<string> ObtenerRubros() { var rubros = inventarioA.Concat(inventarioB).Select(n => n.Rubro).Distinct(); return rubros; }

Notemos que hemos utilizado el método extensor Distinct, el cual evitará tener duplicidad de rubros. Nuestro próximo paso será enlazar el componente cmbRubro con el resultado del método ObtenerRubros. Para ello, generaremos el método PoblarRubros: public void PoblarRubros() { cmbRubro.DataSource = ObtenerRubros().ToList(); }

Básicamente, lo que hacemos es llamar al ObtenerRubros adicionándole el método extensor ToList, debido a que la propiedad DataSource del combobox espera un valor que cumpla con la interface IList, mientras que el retorno de ObtenerRubros es un IEnumerable<>. Obviamente, tanto PoblarRubros como ObtenerRubros podrían haber sido escritos en el mismo método, pero la idea es separarlos para una mejor comprensión del ejemplo. Ahora nos falta conseguir el listado de productos según un rubro especificado: public IEnumerable<string> ObtenerProductos(string rubro) { var invTotalStock = inventarioA.Union(inventarioB). Where(n=>n.Stock>0); var productos = (from producto in invTotalStock where producto.Rubro == rubro orderby producto.Nombre select producto.Nombre).Distinct(); return productos; }


Alfaomega

178

5- Linq

ObtenerProductos necesita como parámetro el rubro por el cual filtrar, es por ello que lo declaramos en la firma del mismo. Si observamos la consulta, notaremos que hemos combinado expresiones de consulta y expresiones con métodos. Gracias a Distinct tendremos un listado de productos únicos, sin tener en la secuencia nombres duplicados. En cierta manera, necesitamos actualizar el combobox que contiene el listado de productos en dos circunstancias: Al cargar el formulario y cuando el cambia de rubro. Es por eso que generamos el método Actualizar: public void Actualizar() { lstProductos.DataSource = ObtenerProductos(cmbRubro.SelectedItem.ToString()).ToList(); }

Simplemente asignamos la propiedad DataSource de nuestro listbox al método ObtenerProductos, enviándole como parámetro de entrada el rubro seleccionado. Al igual que en el caso anterior, el datasource espera un valor que implemente IList. Como mencionamos, es necesario que al cambiar de rubro se actualice el listado de productos. Para lograrlo simplemente en el evento SelectedIndexChanged de nuestro componente cmbRubro, invocaremos al método Actualizar: SULYDWHYRLGFPE5XEURB6HOHFWHG,QGH[&KDQJHGREMHFWVHQGHU EventArgs e) { Actualizar(); }

Ya tenemos todo listo. Ahora es cuestión de ordenar las cosas. En el constructor del formulario llamaremos a los métodos ArmarInventarios, PoblarRubros y Actualizar: public Form1() { InitializeComponent(); ArmarInventarios(); PoblarRubros(); Actualizar(); }

De esta forma, lograremos que al instanciarse el formulario Windows se armen los inventarios con los datos de pruebas; además, poblamos el combobox

Alfaomega



179

con los rubros de productos de ambos depósitos y, por último, actualizamos lstProductos. Si ejecutamos la aplicación, tendríamos algo como lo siguiente (figura5-4):

Fig. 5-4. Ejecutando el ejemplo notaremos que no hay rubros duplicados.

El código completo aquí: Form1.cs: public partial class Form1 : Form { List inventarioA, inventarioB; public Form1() { InitializeComponent(); ArmarInventarios(); PoblarRubros(); Actualizar(); } private void ArmarInventarios() { inventarioA = new List { new Producto{Nombre=”Aceite Girasol”, Rubro=”Aceites”,Stock=10}, new Producto{Nombre=”Mostaza”,Rubro=”Aderesos”, Stock=12},


Alfaomega

180

5- Linq

new Producto{Nombre=”Aceite Oliva”, Rubro=”Aceites”,Stock=0}, new Producto{Nombre=”Mayonesa”,Rubro=”Aderesos”, Stock=56}, new Producto{Nombre=”Gaseeosa Cola”, Rubro=”Bebidas”,Stock=43}, new Producto{Nombre=”Agua sin gas”, Rubro=”Bebidas”,Stock=42}, }; inventarioB = new List { new Producto{Nombre=”Resma A4”, Rubro=”Librería”,Stock=23}, new Producto{Nombre=”Lápiz 2H”, Rubro=”Librería”,Stock=7}, new Producto{Nombre=”Jabón Neutro”, Rubro=”Limpieza”,Stock=91}, new Producto{Nombre=”Detergente”,Rubro=”Limpieza”, Stock=5}, new Producto{Nombre=”Leche”,Rubro=”Lácteos”, Stock=0}, new Producto{Nombre=”Agua sin gas”, Rubro=”Bebidas”,Stock=11}, new Producto{Nombre=”Queso”,Rubro=”Lácteos”, Stock=0}, }; } public void PoblarRubros() { cmbRubro.DataSource = ObtenerRubros().ToList(); } /// <summary> /// Actualiza el listado de productos que tienen stock /// public void Actualizar() { lstProductos.DataSource = ObtenerProductos(cmbRubro. SelectedItem.ToString()).ToList(); } /// <summary> /// Devuelve todos los rubros de ambos inventarios /// /// IEnumerable<string> public IEnumerable<string> ObtenerRubros() {

Alfaomega



181

var rubros = inventarioA.Concat(inventarioB). Select(n => n.Rubro).Distinct(); return rubros; } /// <summary> /// Devuelve productos que poseen stock > 0 de ambos /// inventarios /// /// <param name=”rubro”>El rubro seleccionado en lstRubros /// IEnumerable<string> public IEnumerable<string> ObtenerProductos(string rubro) { var invTotalStock = inventarioA.Union(inventarioB). Where(n=>n.Stock>0); var productos = (from producto in invTotalStock where producto.Rubro == rubro orderby producto.Nombre select producto.Nombre).Distinct(); return productos; } SULYDWHYRLGFPE5XEURB6HOHFWHG,QGH[&KDQJHGREMHFW sender, EventArgs e) { Actualizar(); } }

LINQ a XML Como todos sabemos, XML fue adoptado desde hace ya varios años como un estándar y nos ha ayudado a ordenar nuestros datos de forma excelente. Hoy en día, está presente en diversos ámbitos como archivos de configuración, es utilizado como repositorio de datos, en servicios Web, como medio de intercambio de información entre sistemas dispares, etc. Pero trabajar con XML, independientemente del analizador/traductor (más conocido como parser), muchas veces resultaba bastante incómodo, tanto para la construcción de un modelo basado en XML, como para realizar consultas empleando la API del W3C DOM XML. Muchos hemos utilizado XPath, XQuery o alguna API desarrollada por terceros para minimizar el código necesario en nuestros proyectos.


Alfaomega

182

5- Linq

Disponemos ahora de un proveedor LINQ a XML, una nueva API con un modelo de objetos, que nos permitirá trabajar con XML de forma mucha más rápida y sencilla, tanto para escribir nuestras consultas como para la manipulación de datos jerárquicos. Notaremos que, luego de trabajar con esta interface de programación, nuestro código será más intuitivo y cómodo si lo comparamos con el anterior. Hay un número importante de clases que utilizaremos, que se encuentran en el espacio de nombres System.Xml.Linq y en System.Xml.Schema, pero veamos primero en la figura 5-5 la estructura jerárquica de clases.

Fig. 5-5. Jerarquía de clases en LINQ a XML.

Repasemos entonces las novedades que tiene esta nueva API para los desarrolladores, para luego ir directamente a ver un ejemplo. Construcciones funcionales Se denomina construcción funcional a la posibilidad de crear objetos y su instanciación con valores en una misma declaración, gracias a la implementación de métodos sobrecargados para lograr una estructura de árbol XML. Veamos un ejemplo en C#: XElement Celulares = new XElement(“Celulares”, new XElement(“Marcas”, new XElement(“Motorola”,

Alfaomega



183

new XAttribute(“ID”, 1), new XElement(“Modelo”, “V3i”), new XElement(“Modelo”, “U3”), new XElement(“Modelo”, “V400P”)), new XElement(“Nokia”, new XAttribute(“ID”, 2), new XElement(“Modelo”, “N95”), new XElement(“Modelo”, “6800”), new XElement(“Modelo”, “6620”))));

El resultado sería: xml = <Marcas> <Motorola ID=”1”> <Modelo>V3i <Modelo>U3 <Modelo>V400P <Modelo>N95 <Modelo>6800 <Modelo>6620

Notemos la utilización de los métodos anidados para lograr nuestro cometido y la facilidad con la que podemos interpretar el esquema, realmente mucho más sencillo. Esto implica además cierta facilidad para reutilizar el código, simplemente copiando y pegando podremos extender los datos muy claramente. Recordemos que en Visual Basic el mismo código es más simple: Dim Celulares As XElement = <Marcas> <Motorola ID=”1”> <Modelo>V3i <Modelo>U3 <Modelo>V400P <Modelo>N95 <Modelo>6800 <Modelo>6620


Alfaomega

184

5- Linq

Centricidad en los elementos Antes de utilizar la nueva API de LINQ a XML, para generar un documento XML debíamos generar primero un objeto XmlDocument para luego sí anexarle los del tipo XmlElement: XmlDocument xDocCelulares = new XmlDocument(); XmlElement xElemCelulares = xDocCelulares. CreateElement(“Celulares”);

En Visual Basic: Dim xDocCelulares As New XmlDocument() Dim xElemCelulares = xDocCelulares.CreateElement(“Celulares”)

Con la nueva API disponemos de otra opción. Ahora podremos generar esos objetos sin crear primeramente un XmlDocument, tal como hemos visto en el ejemplo de construcciones funcionales, donde nunca hemos instanciado un XmlDocument y obtuvimos el mismo resultado. Espacio de nombres y prefijos Otra de las ventajas de utilizar LINQ a XML consiste en no tener que declarar explícitamente un prefijo para los espacios de nombres. Debido a que este alias puede adoptar diferentes valores a lo largo del árbol del XML, muchas veces puede prestarse a confusión, obteniendo el valor de un nodo no deseado o, quizá, una excepción. Al procesar un documento, la API resuelve cada prefijo a su correspondiente URI, habilitándonos a acceder a través de éste. De todas maneras, si lo deseamos aún, tendremos soporte para continuar trabajando mediante los alias. Si corremos y depuramos el ejemplo de los celulares, notaremos que el elemento Celulares tiene el valor NameSpace = {} y veremos que LocalName = Celulares. NameSpace adopta ese valor porque nunca definimos un espacio de nombre. Para asignar uno, tenemos varios caminos: XNamespace miNS = “http://www.miempresa.mobi”; XElement Celulares = new XElement(miNS + “Celulares”, new XElement(miNS + “Marcas”, new XElement(miNS + “Motorola”, …

En el código anterior definimos nuestro espacio de nombres y en el constructor de XElement lo asignamos. Alfaomega



185

Si visualizamos en el depurador de Visual Studio, el valor de NameSpace para Celulares es { http://www.miempresa.mobi }. Otra forma de hacerlo es mediante nombre extendido, que responde a la forma {espacio de nombre}nombre local: XElement Celulares = new XElement(“{http://www.miempresa.mobi}Celulares”, new XElement(“{http://www.miempresa.mobi}Marcas”, new XElement(“{http://www.miempresa.mobi}Motorola”,

La respuesta de ambos ejemplos sería: <Marcas> <Motorola ID=”1”> <Modelo>V3i <Modelo>U3 <Modelo>V400P <Modelo>N95 <Modelo>6800 <Modelo>6620

Accediendo a los valores Se ha mejorado sustancialmente el a elementos y valores en LINQ a XML. Con la API anterior debíamos crear, por ejemplo, objetos del tipo XmlNode para recuperar el valor de un nodo en particular y escribir mucho más código cuando el árbol de los datos era complejo y necesitábamos recorrerlo. Ahora podremos obtener los valores de diversas maneras: Mediante el método ToString, la propiedad Value o realizando un cast a un tipo de dato al cual pueda ser convertido: XElement xmlAuto = new XElement(“Marca”, “Subaru”); // Implícitamente llama al método ToString() Console.WriteLine(xmlAutos); Console.WriteLine(xmlAutos.Value); Console.WriteLine((string)xmlAutos); XElement xmlPersona = new XElement(“Edad”, 29); Console.WriteLine(xmlPersonas); Console.WriteLine(xmlPersonas.Value); Console.WriteLine((int)xmlPersonas); Console.Read();


Alfaomega

186

5- Linq

La impresión en pantalla sería: <Marca>Subaru Subaru Subaru <Edad>29 29 29

Métodos para operar en XML En el siguiente cuadro presentaremos algunos de los métodos más utilizados en el día a día para realizar consultas y modificaciones a nuestras estructuras XML. Método

Descripción

XContainer.Element

Devuelve el primer nodo hijo, especificando el nombre como argumento.

XContainer.Elements

Retorna una colección IEnumerable<XElement> de elementos hijos. Posee sobrecarga.

XContainer. Descendants

Devuelve una colección de elementos descendientes. Sobrecargado.

XNode.Remove

Remueve el nodo de su padre.

XNode.Ancestors

Retorna los ancestros de un elemento determinado. Posee sobrecarga.

XNode. ElementsBeforeSelf

Devuelve una colección de elementos relacionados que se encuentran antes de un nodo. Sobrecargado.

XNode. ElementsAfterSelf

Devuelve una colección de elementos relacionados que se encuentran después de un nodo. Sobrecargado.

XElement. AncestorsAndSelf

Retorna una colección de elementos ancestros incluyendo éste. Posee sobrecarga.

XElement. DescendantsAndSelf

Retorna una colección de elementos descendientes incluyendo éste. Posee sobrecarga.

XNode.ReplaceWith

Reemplaza un nodo por el contenido especificado.

XContainer.Add

Agrega el contenido especificado como elementos hijos de un XContainer.

Nota: XContainer representa a un nodo, que a su vez puede contener otros nodos. Sus métodos y propiedades son de gran utilidad al trabajar con LINQ a XML; es por ello que es importante revisar la documentación que tenemos en el sitio MSDN de Microsoft para conocer todo su potencial.

Alfaomega



187

Basándonos en el ejemplo de los celulares, supongamos que deseamos obtener la lista de modelos que pertenecen a la marca Motorola. El código sería algo así: IEnumerable<XElement> celMotorola = Celulares. Descendants(“Motorola”).Elements(“Modelo”); foreach (var cel in celMotorola) { Console.WriteLine((string)cel); } Console.Read();

Respuesta: V3i V3 V400P

Veamos un ejemplo de cómo utilizar LINQ a XML en un proyecto Windows. Pensemos que tenemos el inventario de nuestra empresa en un archivo XML como el siguiente: <producto ID=”1”> MEM51201 <descripcion>Memoria 512 DDR Memorias <deposito>Deposito-A A1 <stock>1000 <producto ID=”2”> MEM100001 <descripcion>Memoria 1GB DDR2 Memorias <deposito>Deposito-A A2 <stock>290 <producto ID=”3”> LCD19005 <descripcion>LCD 19 Pulgadas Monitores <deposito>Deposito-B B1 <stock>178


Alfaomega

188

5- Linq

<producto ID=”4”> MOUWLS09 <descripcion>Mouse Wireless Mouses <deposito>Deposito-B B1 <stock>8 <producto ID=”5”> USBH029 <descripcion>Hub USB 2.0 Extensores <deposito>Deposito-B B1 <stock>69

Tenemos dos depósitos y otras tantas ubicaciones donde se encuentra almacenada nuestra mercadería. La idea es armar una aplicación que nos permita filtrar por depósito, poder llevar el stock a cero y realizar una exportación de las modificaciones realizadas. Comencemos creando un proyecto de formularios Windows y arrastraremos algunos controles como muestra la figura 5-6:

Fig. 5-6. Diseño de la aplicación de inventarios.

El nombre de la grilla es dataGridView1, el correspondiente al botón “Borrar Stock” es btnBorrar y el del botón “Exportar” es btnExportar. Lo primero que haremos será definir una variable XDocument en nuestra clase form1.cs: XDocument xmlInventario;

Alfaomega



189

Crearemos un método para cargar nuestro archivo XML, en donde invocaremos al método Load de XDocument: public void CargarInventario() { xmlInventario = XDocument.Load(@”C:\Inventarios\Inventario. xml”); }

Como paso siguiente, debemos poblar al combo de depósitos con los existentes en el archivo; para ello generamos otro método: public void CargarComboDepositos() { var xDeposito = xmlInventario.Descendants(“producto”). Elements(“deposito”).Select(n=> n.Value).Distinct(); foreach (var item in xDeposito) { cmbDeposito.Items.Add(item); } cmbDeposito.SelectedIndex = 0; }

Notemos cómo mediante los métodos extensores vamos armando nuestra ruta en la jerarquía del XML para conseguir el dato buscado. Luego forzamos a seleccionar el primer índice en el combo, para que al cargar el formulario haya uno seleccionado. Nuestra tarea siguiente será la de armar un método que recibe como parámetro el depósito por el cual filtrar, para mostrar el resultado de nuestra consulta: public void ActualizarGrilla(string deposito) { var xProductos = from prod in xmlInventario. Descendants(“producto”) where prod.Element(“deposito”).Value == deposito select new { ID = (int)prod.Attribute(“ID”), Código = (string)prod.Element(“codigo”), Descripción = (string)prod. Element(“descripcion”), Categoría = (string)prod. Element(“categoria”),


Alfaomega

190

5- Linq

Stock = (int)prod.Element(“stock”), Depósito = (string)prod.Element(“deposito”), Ubicación = (string)prod.Element(“ubicacion”) }; // Cantidad de ítems lblRegistros.Text = xProductos.Count().ToString(); // Cantidad de categorías de productos lblCategorias.Text = xProductos.Where(n => n.Categoría.Length > 0).GroupBy(n => n.Categoría).Count().ToString(); // Cantidad de ubicaciones en función del depósito lblUbicaciones.Text = xProductos.Where(n => n.Ubicación.Length > 0).GroupBy(n => n.Ubicación).Count().ToString(); dataGridView1.DataSource = xProductos.ToArray(); }

Aquí, además, estamos actualizando las etiquetas correspondientes a las cantidades de productos encontrados, categorías y ubicaciones. Sabemos que cuando el seleccione un depósito en el combo, debemos actualizar nuestra grilla. Para ello, si hacemos doble clic sobre el componente cmbDeposito, Visual Studio generará el evento asociado por defecto, en este caso SelectedIndexedChanged:

SULYDWHYRLGFPE'HSRVLWRB6HOHFWHG,QGH[&KDQJHGREMHFWVHQGHU EventArgs e) { // Actualizamos la grilla y enviamos como parámetro el // depósito seleccionado ActualizarGrilla(cmbDeposito.SelectedItem.ToString()); }

Otro requerimiento que tenemos es que, al iniciar el formulario, se cargue el archivo XML en memoria y luego se carguen los depósitos en el combo. Para lograrlo, simplemente debemos llamar a los métodos CargarInventario y CargarComboDepositos desde el constructor: public Form1() { InitializeComponent(); CargarInventario(); CargarComboDepositos(); }

Alfaomega



191

El botón Borrar tiene por finalidad llevar el stock de productos que se encuentren en nuestra grilla a cero. Para tal operación, creamos un método al que le pasaremos el depósito en cuestión y, mediante la instrucción foreach, utilizamos el método ReplaceWith de XElement: public void BorrarStock(string deposito) { var borrarStock = xmlInventario.Descendants(“producto”). Where(n => n.Element(“deposito”).Value == deposito). Elements(“stock”); foreach (XElement item in borrarStock) { item.ReplaceWith(new XElement(“stock”,0)); } }

En el evento clic del botón realizamos la invocación al mismo y al método ActualizarGrilla para actualizar los datos representados: SULYDWHYRLGEWQ%RUUDUB&OLFNREMHFWVHQGHU(YHQW$UJVH { BorrarStock(cmbDeposito.SelectedItem.ToString()); // Actualizamos la grilla ActualizarGrilla(cmbDeposito.SelectedItem.ToString()); }

Realizar la exportación del objeto en memoria xmlInventario a un archivo XML es tan sencillo como llamar al método Save de XDocument. public void Exportar() { string archivo = “InventarioExportado.xml”; try { xmlInventario.Save(@”C:\Inventarios\Exportados\” + archivo); } catch (Exception ex) { MessageBox.Show(ex.Message,”Se detectó un error!!”, MessageBoxButtons.OK,MessageBoxIcon.Exclamation); return; } MessageBox.Show(“Exportación exitosa”, “Exportar”, MessageBoxButtons.OK, MessageBoxIcon.Asterisk); }


Alfaomega

192

5- Linq

Y el evento clic del botón Exportar quedaría así: SULYDWHYRLGEWQ([SRUWDUB&OLFNREMHFWVHQGHU(YHQW$UJVH { Exportar(); }

En nuestro caso hemos especificado la ruta de forma fija. Otra opción podría haber sido pedirle al que seleccione la carpeta de destino mediante un componente FolderBrowserDialog. Si ejecutamos la aplicación (figura 5-7), veremos cómo al seleccionar un depósito los datos son actualizados en la grilla. Otra prueba interesante es llevar a cero el stock de algunos productos, exportar a un archivo XML y, con el Internet Explorer u otro aplicativo, ver cómo fueron impactadas esas modificaciones en el archivo de destino.

Fig. 5-7. Ejecutando nuestra aplicación.

A continuación, el código completo:

Alfaomega



using using using using using using using using using using

193

System; System.Collections.Generic; System.ComponentModel; System.Data; System.Drawing; System.Linq; System.Text; System.Windows.Forms; System.Xml.Linq; System.Collections;

QDPHVSDFH(MHPSOR:LQ)RUP { public partial class Form1 : Form { XDocument xmlInventario; public Form1() { InitializeComponent(); CargarInventario(); CargarComboDepositos(); } public void CargarInventario() { xmlInventario = XDocument.Load(@”C:\Inventarios\ Inventario.xml”); } public void CargarComboDepositos() { var xDeposito = xmlInventario. Descendants(“producto”).Elements(“deposito”).Select(n=> n.Value).Distinct(); foreach (var item in xDeposito) { cmbDeposito.Items.Add(item); } cmbDeposito.SelectedIndex = 0; } public void ActualizarGrilla(string deposito) { var xProductos = from prod in xmlInventario. Descendants(“producto”) where prod.Element(“deposito”).Value == deposito select new { ID = (int)prod.Attribute(“ID”), Código = (string)prod.Element(“codigo”),


Alfaomega

194

5- Linq

Descripción = (string)prod. Element(“descripcion”), Categoría = (string)prod. Element(“categoria”), Stock = (int)prod.Element(“stock”), Depósito = (string)prod. Element(“deposito”), Ubicación = (string)prod. Element(“ubicacion”) }; lblRegistros.Text = xProductos.Count().ToString(); lblCategorias.Text = xProductos.Where(n => n.Categoría.Length > 0).GroupBy(n => n.Categoría).Count().ToString(); lblUbicaciones.Text = xProductos.Where(n => n.Ubicación.Length > 0).GroupBy(n => n.Ubicación).Count().ToString(); dataGridView1.DataSource = xProductos.ToArray(); } public void BorrarStock(string deposito) { var borrarStock = xmlInventario. Descendants(“producto”).Where(n => n.Element(“deposito”).Value == deposito).Elements(“stock”); foreach (XElement item in borrarStock) { item.ReplaceWith(new XElement(“stock”,0)); } } public void Exportar() { string archivo = “InventarioExportado.xml”; try { xmlInventario.Save(@”C:\Inventarios\Exportados\” + archivo); } catch (Exception ex) { MessageBox.Show(ex.Message,”Se detectó un error!!”, MessageBoxButtons.OK,MessageBoxIcon.Exclamation); return; } MessageBox.Show(“Exportación exitosa”, “Exportar”, MessageBoxButtons.OK, MessageBoxIcon.Asterisk); }

Alfaomega



195

SULYDWHYRLGFPE'HSRVLWRB6HOHFWHG,QGH[&KDQJHGREMHFW sender, EventArgs e) { ActualizarGrilla(cmbDeposito.SelectedItem. ToString()); } SULYDWHYRLGEWQ%RUUDUB&OLFNREMHFWVHQGHU(YHQW$UJVH { BorrarStock(cmbDeposito.SelectedItem.ToString()); ActualizarGrilla(cmbDeposito.SelectedItem. ToString()); } SULYDWHYRLGEWQ([SRUWDUB&OLFNREMHFWVHQGHU(YHQW$UJVH { Exportar(); }

} }

LINQ a SQL Al igual que LINQ a XML, disponemos de una nueva API en el .Net Framework 3.5 para utilizar LINQ en bases de datos relacionales SQL Server 2000, 2005 y 2008, SQL Express y SQL Server Compact 3.5 Si necesitamos trabajar con otras marcas de bases de datos, podemos crear nuestro propio proveedor. Lo que LINQ a SQL nos ofrece es un modelo de objetos que se mapean a la base de datos física, proveyéndonos de una delgada aislación para realizar operaciones de consultas y modificaciones sobre las diversas tablas y vistas del sistema. Mediante esta API podremos utilizar procedimientos almacenados y funciones definidas por el de forma transparente, siempre como un modelo de objetos. Entidades de clases La base fundamental de LINQ a SQL son las clases de entidades, en donde cada tabla o vista de nuestra base de datos será representada en nuestro modelo de objetos como una clase, que a su vez posee tantas propiedades como columnas exista en su correspondiente tabla o vista.


Alfaomega

196

5- Linq

Las relaciones claves primarias - claves foráneas son mapeadas como asociaciones, donde una entidad padre contiene una colección de clases de entidades hijas y éstas mantienen una referencia a su padre. Básicamente, hay cuatro formas de generar estas clases: %

Generando a mano las entidades mediante una serie de atributos (espacio de nombres utilizado para ello: System.Data.Linq.Mapping).

%

A través de un archivo externo con formato XML.

%

Mediante la herramienta de consola SqlMetal.exe (viene con el Visual Studio 2008).

%

Utilizando el diseñador gráfico de relaciones de objetos integrado en el Visual Studio 2008.

Nosotros haremos uso de la última opción, dado que es la más intuitiva y fácil de comprender en nuestro primer o y, quizá, sea la que emplearemos más comúnmente en el día a día. Antes habíamos mencionado que podemos utilizar LINQ a SQL con la base de datos SQL Server Compact 3.5. Pero, al momento de escribir este libro, el diseñador de Visual Studio no soporta esta caracteristica, por ende deberemos hacer uso de SqlMetal.exe para crear nuestras clases de entidades. El DataContext Es una clase fundamental en este tema, al igual que las clases de entidades, dado que provee importantes funciones tales como la conexión a la base de datos, la istración de los cambios que ocurran en nuestro modelo de objetos, persistencia y seguimiento de modificaciones. Además, es quien traduce en lenguaje T-SQL las consultas y operaciones que hagamos sobre las entidades. Posee un constructor sobrecargado para enviar como parámetro, entre otras cosas, un objeto SqlConnection o un string con la cadena correspondiente. Una ventaja que ofrece trabajar con el diseñador relacional de objetos es que crea y configura por nosotros el datacontext. En la figura 5.8 tenemos una representación de los mapeos entre el modelo de objetos y el modelo relacional. Nada mejor para comprender un tema que analizar un ejemplo. Para esta demostración utilizaremos la base de datos Northwind. Para aquellos que tengan instalado SQL Server 2005, la pueden descargar del sitio de descargas de Microsoft y correr un script muy sencillo que la generará muy rápidamente. Crearemos un proyecto Web y dispondremos algunos controles en el formulario, tal como muestra la figura 5-9.

Alfaomega



197

Fig. 5-8. Mapeos entre objeto y modelo relacional.

Fig. 5-9. Distribución de componentes.

Nuestra intención es obtener un listado de pedidos de empresas argentinas con sus respectivos vendedores; para ello, nos basaremos principalmente en tres tablas : Orders (pedidos), Customers (clientes) y Employees (empleados o vendedores). Luego de generado el proyecto, utilizaremos el diseñador relacional de objetos para generar nuestro modelo de objetos, que se mapearán a las tablas antes mencionadas. Posicionados sobre el proyecto agregaremos un nuevo ítem, bajo la categoría Datos, seleccionaremos la plantilla Clases de LINQ a SQL y le asignaremos como nombre Northwind.dbml, tal como muestra la figura 5-10.


Alfaomega

198

5- Linq

Fig. 5-10. Agregando nuestro archivo dbml.

Éste nos mostrará la pantalla del diseñador, que se encargará, entre otras cosas, de generar nuestra clase DataContext, cuyo nombre por defecto es nombre-archivo-dbmlDataContext (figura 5-11).

Fig. 5-11. Vista del diseñador relacional de objetos.

Nuestro próximo paso es agregar las tablas mencionadas a la superficie del diseñador. Para esto, debemos tener una conexión ya generada a nuestro servidor SQL en el explorador de servidores. En este punto es donde se realizan los mapeos y asociaciones, las tablas son traducidas en clases y sus columnas en propiedades, mientras que las relaciones clave primaria–clave foránea son Alfaomega



199

representadas en asociaciones. Desde aquí podemos realizar modificaciones en los nombres y configurar el comportamiento para inserciones, actualizaciones y borrado. En la figura 5-12 se muestra este punto.

Fig. 5-12. Mapeos a clases y asociaciones de las tablas y sus relaciones PK-FK .

Vayamos ahora a la vista de código de la clase Default.aspx.cs. Debemos construir una consulta que recolecte los datos que precisamos y sean enlazados al control GridView: public void MostrarPedidos() { // Intanciamos nuestra clase DataContext ya generada por el // diseñador NorthwindDataContext dc = new NorthwindDataContext(); // Consulta var pedidos = from p in dc.Orders MRLQFLQGF&XVWRPHUVRQS&XVWRPHU,'HTXDOV c.CustomerID MRLQHLQGF(PSOR\HHVRQS(PSOR\HH,'HTXDOV e.EmployeeID where c.Country == “Argentina” orderby p.OrderID select new { Pedido = p.OrderID, Empresa = c.CompanyName, o = c.Name,


Alfaomega

200

5- Linq

CodigoVendedor = e.EmployeeID, Vendedor = e.FirstName + “ “ + e.LastName, DireccionEntrega = p.ShipAddress, CiudadEntrega = p.ShipCity }; // Enlazamos con el GridView GridView1.DataSource = pedidos; GridView1.DataBind();

}

Invocaremos este método desde el Page_Load de la página y desde el evento Click del botón Mostrar Pedidos. Si ejecutamos la aplicación, tendremos en pantalla el listado de pedidos correspondiente a clientes residentes en Argentina. Tomemos como caso el pedido número 10 409 (figura 5-13), cuyo vendedor es Janet Leverling con código de vendedor 3.

Fig. 5-13. Pedidos que cumplen nuestro criterio de búsqueda.

Con LINQ a SQL no sólo podremos hacer consultas, sino también inserciones, actualizaciones y borrado desde el modelo de objetos, para luego impactar en la base de datos relacional. En el código siguiente vemos cómo crear e insertar un vendedor:

Alfaomega



201

public void InsertarVendedor() { NorthwindDataContext dc = new NorthwindDataContext(); Employees employee = new Employees(); 'DPRVYDORUDODVSURSLHGDGHVGHOREMHWR(PSOR\HHV employee.FirstName = “Pablo”; employee.LastName = “Rodriguez”; employee.Title = “Vendedor”; dc.Employees.InsertOnSubmit(employee); try { dc.SubmitChanges(); } catch (Exception ex) { // Loguear ex.Message } }

Notemos la llamada al método SubmitChanges del datacontext. Aquí es donde persisten todas las modificaciones pendientes de realizar a la base de datos. Es muy importante tener en cuenta que podemos tener conflictos y errores al ejecutar esta línea; por ello, debemos ejecutarla dentro de un bloque Try-Catch y manejar cualquier excepción que pudiera ser elevada. En el evento Click del botón Crear Vendedor invocamos este método. Al ejecutar la solución y hacer clic sobre dicho componente, podremos ver en la base de datos este nuevo registro (figura 5.14). Tomemos nota del ID que posee: 10.

Fig. 5-14. Nuevo vendedor insertado con LINQ.


Alfaomega

202

5- Linq

Nuestra intención será reemplazar al vendedor que posee el pedido 10 409 por el nuevo generado: public void ActualizarPedido() { NorthwindDataContext dc = new NorthwindDataContext(); // Buscamos el pedido Orders pedido = dc.Orders.Single(n => n.OrderID == 10409); pedido.EmployeeID = 10; try { dc.SubmitChanges(); } catch (Exception ex) { // Loguear ex.Message } }

Desde el evento Click del botón Actualizar Pedido llamaremos a este método. Si corremos la solución, presionamos este botón y luego hacemos clic en Mostrar Pedidos, podemos observar que han cambiado los valores de CodigoVendedor y Vendedor por el nuevo creado en el paso anterior. Como último paso, restauraremos el vendedor original del pedido y procederemos a borrar de la tabla el creado por nosotros: public void BorrarVendedor() { NorthwindDataContext dc = new NorthwindDataContext(); Orders pedido = dc.Orders.Single(n => n.OrderID == 10409); pedido.EmployeeID = 3; try { dc.SubmitChanges(); } catch (Exception ex) { // Loguear ex.Message } Employees vendedor = dc.Employees.Single(n=> n.EmployeeID==10); dc.Employees.DeleteOnSubmit(vendedor); try { dc.SubmitChanges();

Alfaomega



203

} catch (Exception ex) { // Loguear ex.Message } }

El primer paso es cargar al vendedor anterior y luego borrar el generado. Si lo hubiésemos hecho al revés, obtendríamos un error, dado que entre Orders y Employees hay una relación PK-FK. Este método debe ser invocado desde el evento Click del botón Borrar Vendedor. En tiempo de ejecución, al presionar el botón notaremos que ahora el pedido 10 409 tiene su valor original y si ejecutamos una consulta a la tabla Employees veremos que no tenemos más este registro. Ejecutar un procedimiento almacenado o una función es tan sencillo como llamar a un método. El siguiente código es de aplicación de consola, utilizando el mismo DataContext del ejemplo anterior. class Program { static void Main(string[] args) { NorthwindDataContext dc = new NorthwindDataContext(); (QYLDPRVDFRQVRODODVHQWHQFLD764/HMHFXWDGD dc.Log = Console.Out; // El procedimiento almacenado es mapeado como un método. // Devuelve los 10 productos más caros var Productos = dc.Ten_Most_Expensive_Products(); foreach (var item in Productos) { Console.WriteLine(item.TenMostExpensiveProducts + “-” + item.UnitPrice); } Console.Read(); } }

LinqDataSource Es un control para formularios Web que lo podemos usar para conectarnos a orígenes de datos, ya sea una base de datos o una colección en memoria, y enlazarlo a controles como GridView, ListView o DropDownList, entre otros. Dejaremos su uso para el capítulo de ASP.NET. Visual Studio - Firtman, Natale

Alfaomega

204

5- Linq

LINQ a DataSet Como su nombre lo indica, es el proveedor que nos permitirá realizar consultas LINQ sobre datasets, utilizando la misma sintaxis de consulta tal como lo hemos hecho hasta aquí. Para soportar esto, se han agregado métodos extensores en las clases DataRowExtension y DataTableExtension, entre otras. Podremos emplear LINQ tanto para dataset tipado como no tipado, aunque con algunas pequeñas diferencias que veremos luego. Lo importante de todo esto, es que en la mayoría de las aplicaciones se trabajan con datasets y, al programar en .Net Framework 3.5, podremos aprovechar toda la potencia de LINQ para la manipulación de datos de diversos orígenes a los cuales ADO.Net nos permita conectar. Para realizar consultas debemos trabajar con colecciones; es por eso que disponemos del método AsEnumerable, el cual sabemos que pertenece a DataTableExtension, que devolverá una tabla como una secuencia de DataRow ( IEnumerable ). DataSet no tipado Cuando nos encontramos frente a un dataset no tipado, sabemos que la operatoria de obtener y asignar valores requiere algunos pasos extra como producto de la ausencia de un archivo de esquemas, el cual muchas veces se traduce en errores en tiempo de ejecución. Se han agregado dos métodos extensores dentro de la clase estática DataRowExtension: Field y SetField y, como se imaginarán por su significado en ingles, los utilizaremos para recuperar y asignar, respectivamente, valores en un DataRow (clase que representa una fila en un DataTable). Sin entrar en mayores detalles, Field resuelve algunos problemas cotidianos, dado que posee compatibilidad con valores null y soluciona un inconveniente cuando trabajamos con comparaciones entre filas, debido a un proceso conocido como boxing. Es importante que tengamos en cuenta que los tipos que reemplazaremos en deben coincidir con el valor esperado en función de la columna que se esté tratando, caso contrario vamos a obtener una excepción InvalidCastException. A continuación vamos a ver un ejemplo donde utilizamos la base de datos Northwind, puntualmente las tablas Products y Categories, para obtener un listado de productos que pertenecen a una categoría puntual, que luego será enlazado a un DataGridView por medio de un bindingsource:

Alfaomega



205

public void CargarDataSet() { // Listado de productos string strQueryProductos = “SELECT * FROM PRODUCTS”; // Listado de categorías string strQueryCategories = “SELECT * FROM CATEGORIES”; // Conexión a la base de datos string strConn = “Data Source=LAPTOPXP;Initial Catalog=Northwind;Trusted_Connection=yes”; // DataSet y carga de registros en los DataTable DataSet ds = new DataSet(“Inventario”); SqlDataAdapter da = new SqlDataAdapter(strQueryProductos, strConn); da.Fill(ds, “Productos”); da.SelectCommand.CommandText = strQueryCategories; da.Fill(ds, “Categorias”);

var inventario = from p in ds.Tables[“Productos”].AsEnumerable() MRLQFLQGV7DEOHV>³&DWHJRULDV´@$V(QXPHUDEOH on p.Field (“CategoryID”) equals c.Field (“CategoryID”) where c.Field<string>(“CategoryName”) == “Condiments” select new { Producto = p.Field<string>(“ProductName”), Categoria = c.Field<string>(“CategoryName”), PrecioUnidad = p.Field<decimal>(“UnitPrice”), Stock = p.Field<short>(“UnitsInStock”) }; bindingSourceInventario.DataSource = inventario; // Cantidad de registros encontrados string CantidadRegistros = inventario.Count().ToString(); }

Notemos de qué manera invocamos el método AsEnumerable de cada DataTable, para obtener un IEnumerable y poder confeccionar nuestra consulta, y cómo cada método Field tiene representado el tipo de dato en relación con la columna especificada. Supongamos que quisiéramos actualizar el precio unitario de todos los productos de la tabla, utilizaríamos SetField de la siguiente manera: Visual Studio - Firtman, Natale

Alfaomega

206

5- Linq

foreach (DataRow row in ds.Tables[“Productos”].Rows) { row.SetField<decimal>(“UnitPrice”, row. Field<decimal>(“UnitPrice”) * 2); }

DataSet tipados Aquí la historia cambia. Escribiremos menos código y será mucho más intuitivo al no tener que utilizar AsEnumerable, Field o SetField, producto de que los objetos DataTable fuertemente tipados derivan de la clase TypedTableBase que implementa la interface IEnumerable . Observemos el siguiente ejemplo: public void CargarDataSetTipado() { string strQueryProductos = “SELECT * FROM PRODUCTS”; string strQueryCategories = “SELECT * FROM CATEGORIES”; string strConn = “Data Source=LAPTOPXP;Initial Catalog=Northwind;Trusted_Connection=yes”; // DataSet tipado ProductosDataSet Inventario = new ProductosDataSet(); SqlDataAdapter da = new SqlDataAdapter(strQueryProductos, strConn); da.Fill(Inventario, “Products”); da.SelectCommand.CommandText = strQueryCategories; da.Fill(Inventario, “Categories”); var inventarioSinFiltrar = from p in Inventario.Products MRLQFLQ,QYHQWDULR&DWHJRULHV on p.CategoryID equals c.CategoryID select new { Producto = p.ProductName, Categoria = c.CategoryName, PrecioUnidad = p.UnitPrice, Stock = p.UnitsInStock }; bindingSourceInventario.DataSource = inventarioSinFiltrar; string CantidadRegistros= inventarioSinFiltrar.Count(). ToString(); }

Alfaomega



207

Lo beneficioso de trabajar con datasets tipados es que podremos llamar directamente a las tablas y a sus columnas ayudados por el IntelliSense. CopyToDataTable Este método extensor nos habilitará para poder generar un DataTable desde otro ya existente, o desde una consulta, de la siguiente forma: public void CopiarTabla() { string strQueryProductos = “SELECT * FROM PRODUCTS”; string strConn = “Data Source=LAPTOPXP;Initial Catalog=Northwind;Trusted_Connection=yes”; ProductosDataSet Inventario = new ProductosDataSet(); SqlDataAdapter da = new SqlDataAdapter(strQueryProductos, strConn); da.Fill(Inventario, “Products”); var inventario = from p in Inventario.Products where p.ProductID > 10 select p; // Generando una tabla desde una ya existente DataTable tablaDuplicada = Inventario.Products. CopyToDataTable(); // Generando una tabla desde una consulta DataTable tablaDesdeConsulta = inventario.CopyToDataTable();

bindingSourceInventario.DataSource = tablaDesdeConsulta; }

Lo interesante es que mediante este operador podremos obtener copias de tablas, donde los registros resultantes sean el producto de algún filtro en una consulta u operaciones de agregación o agrupación, entre otras. En el ejemplo estamos enlazando el bindingsource a la tabla generada a través de la consulta, pero también podríamos haber asignado tablaDuplicada. DataRowComparer Mediante esta clase podremos realizar comparaciones entre objetos DataRow basados en los valores de cada uno de ellos y no por referencia. Es muy utilizado cuando empleamos algunas de las operaciones de comparación, como Union o Distinct, donde emplean valuaciones por referencia y no por valor. Esto muVisual Studio - Firtman, Natale

Alfaomega

208

5- Linq

chas veces origina inconvenientes, dado que uno como desarrollador inconscientemente espera que la comparativa sea realizada por el valor específico que tiene el objeto y no por su posición en memoria. Pensemos que tenemos dos tablas, una con el inventario total de productos de nuestro depósito y otra de productos discontinuados en general. Si quisiéramos obtener el listado de ítems que ya no se fabrican (discontinuados) que figuran en el inventario general, podríamos escribir el código que figura a continuación: var resultado = tablaDiscontinuados. Intersect(tablaInventario, DataRowComparer.Default);

Alfaomega


209

ASP.NET

6

Historia Ya todos sabemos de qué se trata ASP.NET, la plataforma de desarrollo Web de Microsoft. También sabemos que, en los últimos años, el desarrollo de aplicaciones Web fue aumentando considerablemente respecto de los desarrollos para escritorio, fomentando cada vez más el uso del navegador Web como plataforma para ejecutar nuestras aplicaciones. Tecnologías Web 2.0, como AJAX, han fomentado más la plataforma Web, así como el concepto de servicios en la nube (cloud computing), donde nuestras aplicaciones residen en servidores virtuales istrados de manera sencilla y escalable sin límite. Esta evolución del mercado Web ha traído muchos cambios en la industria, hasta la aparición de Google en el mercado de los navegadores con su Google Chrome. Es por eso que no sorprende ver que ASP.NET es la plataforma con más cambios dentro del ambiente .NET, desde sus primeras versiones, y sigue evolucionando a un ritmo, a veces, alarmante. Pasado Así es que evolucionamos del antepasado, creado en 1996, ASP (del inglés, Active Server Pages, que significa Páginas Activas del Servidor) a la nueva y revolucionaria plataforma ASP.NET 1.0, en enero de 2002. Con sus ventajas y desventajas, la versión 1.1 solucionó algunos errores y nos ayudó con algunas cuestiones básicas de la plataforma. Pero fue con la versión ASP.NET 2.0, junto con Visual Studio 2005 y .NET Framework 2.0, que la plataforma dio un salto cuantitativo en el mercado de desarrollo Web. Todavía cuesta creer que haya un gran porcentaje de desarro-


Alfaomega

210

6- ASP.NET

lladores que sigan trabajando con ASP Clásico o ASP.NET 1.1. Es por eso que haremos un repaso de las características fundamentales que ASP.NET 2.0 agregó y que son la base de las últimas incorporaciones a la plataforma. Con la salida del Framework 3.0, ASP no ofreció nada distintivo y es por eso que se considera que ASP.NET 3.0 no existió. Siguió siendo ASP.NET 2.0, que se ejecutaba sobre el Framework 3.0. Los únicos agregados menores fueron, además del cambio de framework y sus novedades, la posibilidad de publicar y consumir servicios WCF (Windows Communication Foundation) así como de identificarse con Windows CardSpace. Entre la versión 2.0 y la siguiente versión oficial, se fueron lanzando algunos nuevos frameworks y productos por separado, como ser el excelente framework ASP.NET AJAX –el que detallaremos en el siguiente capítulo–. También se comenzó a trabajar en otros proyectos paralelos, en versiones preliminares, como ser Dynamic Data (Datos Dinámicos), Dynamic Languages (Lenguajes Dinámicos), ASP.NET MVC, entre otros. Presente La siguiente versión oficial fue ASP.NET 3.5. Esta versión fue lanzada junto con el .NET Framework 3.5 y Visual Studio 2008 y, además de incorporar algunos frameworks que estaban separados, como ASP.NET AJAX, incorporó soporte de LINQ, algunos nuevos controles de datos y soporte de WCF para generación de contenido en formato Web –como ser RSS o JSON–. Casi por primera vez en la historia de ASP, un Service Pack (SP) incorporó realmente notorias mejoras en la plataforma. Así, apenas algunos meses después de la salida de 3.5, se publicó ASP.NET 3.5 SP1, que es la última versión disponible mientras este libro es editado, junto con Visual Studio 2008 SP1 y .NET Framework 3.5 SP1. Esta última versión incorpora a la plataforma, oficialmente, el modelo Dynamic Data, soporte de navegación con el botón de Atrás para el framework de AJAX y algunas otras mejoras –como soporte de datos para SQL Server 2008–. Futuro El futuro de ASP.NET sigue con marcha firme y, al momento de editar este libro, ASP.NET 4.0 será la futura plataforma. Incorporará a todo lo anterior: Los frameworks actualmente aislados, como ser ASP.NET MVC, URL Routing y las plantillas AJAX (AJAX Templates), las cuales analizaremos más adelante.

Alfaomega


Proyectos ASP.NET

211

Proyectos ASP.NET Diferencias en Visual Studio Desde la versión 2008 SP1 de Visual Studio y Visual Web Developer, el entorno nos permite trabajar con dos modalidades: Modalidad Proyecto Aplicación Web (Web Application Project) o Sitio Web (Web Site). Para versiones anteriores de Visual Studio, es posible descargar un agregado gratuito para poder tener estos dos tipos de modalidad.

Fig. 6-1. En Visual Web Developer encontramos las dos metodologías de trabajo para ASP.NET.

Un sitio ASP.NET con modalidad Proyecto Aplicación Web trabaja con una solución de Visual Studio, al estilo de aplicaciones Windows Forms o aplicaciones ASP en Visual Studio 2003. Esto implica tener, por un lado, los archivos de la solución y del proyecto y por otro lado, los archivos que se han de publicar en el sitio Web (.aspx, entre otros). Este modelo, además utiliza una precompilación del código .NET (C# o Visual Basic), por lo que para cualquier cambio en el proyecto es necesario regenerarlo y publicar el DLL modificado. Un sitio ASP.NET con modalidad Sitio Web no es más que una carpeta en el disco con los archivos necesarios para el funcionamiento, como si se tratara del servidor Web en forma directa. Esto incluye .aspx, .aspx.cs, .aspx.vb, .dll y todo el código sin precompilar en la carpeta App_Code. Visual Studio - Firtman, Natale

Alfaomega

212

6- ASP.NET

Cualquier cambio en el proyecto, basta con cambiar el archivo en cuestión y refrescar la página en el navegador. El motor de ASP.NET detectará el cambio y realizará la compilación en el momento. Recordemos que este modelo no significa que las páginas no serán compiladas, con la consecuente mejora de rendimiento. El modelo no precompila, sino que lo hace en el momento que considera que la versión compilada que posee no es válida.

Tipos de Aplicaciones Web Si tenemos en cuenta ASP.NET 3.5 SP1, junto con los frameworks definitivos que se pueden descargar por separado y que serán parte integral de ASP.NET 4.0, al iniciar un proyecto nuevo en la plataforma ASP.NET tendremos que elegir qué modelo de trabajo vamos a utilizar. Veamos un repaso de cada uno de ellos. Formularios Web Los formularios Web, o Web Forms en inglés, son el clásico modo de trabajo de ASP.NET, desde sus primeras versiones. Estamos hablando de archivos .aspx, que disponen de PostBacks para interactuar con el , y de los controles Web que dispongamos en cada una de las páginas. Cada ASPX referencia a una funcionalidad o formulario de nuestro sitio Web y es una URL (dirección Web) válida dentro del sitio. Podemos vincular cada formulario Web a través de hipervínculos (links) y utilizar los más de sesenta controles Web disponibles en el framework. En este tipo de proyectos, seguiremos utilizando el arrastrar y soltar componentes en Visual Studio y configurarlos en el asistente o en la ventana de propiedades. Podemos capturar eventos, ya sea de la página (como el conocido Page_Load) o de cada uno de los controles (como el Click de un botón). ASP.NET AJAX Estos proyectos utilizan el nuevo framework ASP.NET AJAX, incorporado en ASP. NET 3.5, o como producto aparte para la versión 2.0 en www.asp.net/ajax. Sin adelantarnos demasiado al próximo capítulo, podemos mencionar que la interacción con el cambia respecto de los clásicos formularios Web y mucha funcionalidad se realizará sobre la misma página o URL, ofreciendo cambios dinámicos y parciales en la aplicación Web, según la interacción del . Esta metodología de trabajo implica utilizar los nuevos controles de AJAX en los formuarios Web, utilizar la nueva librería de cliente JavaScript para AJAX –y su integración con la conocida librería jQuery– y/o los controles ricos conocidos como AJAX Control Toolkit, que repasaremos más adelante en el libro.

Alfaomega


Proyectos ASP.NET

213

ASP.NET MVC Propuesto como un modelo alternativo (no como competencia) de los formularios Web, actualmente está disponible como una descarga adicional desde www.asp.net/mvc y será incorporado en ASP.NET 4.0 como parte de la plataforma. Este modelo no utiliza formularios Web para una aplicación. El modo de trabajo sigue el patrón de diseño Modelo Vista Controlador (en inglés, Model View Controller) y utiliza una metodología de trabajo totalmente diferente a la que conocemos, que es de utilidad para algunos tipos de proyectos Web y es muy sencillo realizar las pruebas (testing) sobre ellas. Dejaremos para más adelante la explicación detallada y los ejemplos de esta nueva modalidad. Datos Dinámicos El framework de Dynamic Data (Datos Dinámicos en español) fue incorporado a la plataforma en la versión 3.5 SP1 y está disponible como descarga adicional para las versiones anteriores en www.asp.net/dynamicdata. Un proyecto iniciado de este tipo permite crear todo un sistema ABMC (Alta, Baja, Modificación y Consulta), también conocido en inglés como CRUD (Create, Read, Update and Delete, es decir, Crear, Leer, Actualizar y Eliminar). Esto implica crear un sitio totalmente funcional que trabaje sobre un modelo de datos LINQ To SQL o Entity Framework, sin necesitar de código ni trabajo para su funcionamiento. Más adelante nos adentraremos en este excelente nuevo tipo de proyecto ASP.NET. Web Forms

AJAX Web Forms

ASP.NET MVC

Dynamic Data

Web Services

ASP Framework .NET Framework Common Language Runtime Fig. 6-2. Arquitectura de los tipos de proyecto en ASP.NET.


Alfaomega

214

6- ASP.NET

Fundamentos Podemos decir que los creadores de la plataforma han escuchado a los desarrolladores y han tenido en cuenta muchos de los comentarios y pedidos de los programadores luego de la versión ASP.NET 1.1.

Controles Web Se ha mantenido la compatibilidad de todos los controles Web de la versión 1.0, junto con sus propiedades y métodos. Sin embargo, se han agregado unos cincuenta controles nuevos que, dada la gran cantidad, han tenido que ser agrupados en categorías. Los controles nuevos que tenemos disponibles desde 2.0 son los siguientes: s

s

s

Controles Estándar – ImageMap – File – MultiView – TreeView – BulletedList – HiddenField – Literal – Wizard – View – Substitution – Localize (3.5)

Controles de Navegación – SiteMapPath – Menu – TreeView

s

Controles de – – View – Recovery – Status – Name – CreateWizard – Change

Controles de Datos s – GridView – DetailsView – FormView – ListView (3.5) – DataPager (3.5) – SqlDataSource – AccessDataSource – ObjectDataSource – XmlDataSource – SiteMapDataSource – LinqDataSource (3.5) – EntityDataSource (3.5 SP1) – DynamicDataManager (3.5 SP1) – DynamicControl (3.5 SP1) Controles de Validación –

Alfaomega

s

DynamicValidator (3.5 SP1)

s

Controles de WebParts – WebPartManager – ProxyWebPartManager – WebPartZone – CatalogZone – DeclarativeCatalogPart – PageCatalogPart – ImportCatalogPart – EditorZone – AppearanceEditorPart – BehaviourEditorPart – LayoutEditorPart – PropertyGridEditorPart – ConnectionsZone Extensiones AJAX (3.5) – ScriptManager – ScriptManagerProxy – Timer – Update – UpdateProgress


Fundamentos

215

Cambios en el objeto Page El objeto Page, que referencia a toda página Web en una aplicación ASP.NET, ha sufrido muchas mejoras. Además de todas las características, atributos y métodos que tenía en la versión 1.x, ahora disponemos de MasterPages, que nos permitirá realizar herencia visual en WebForms; Themes y Skins, que nos permitirán mantener una interfaz gráfica de coherente en todo el sitio Web; y Localization, para mejorar el manejo de información localizada. Ahora es posible que la etiqueta HTML lleve runat=”server” y así podamos definir, por ejemplo, el título de una página desde código con Page.Title El ciclo de vida del objeto Page es similar al siguiente, marcando cuáles son los nuevos eventos más importantes: Evento

Descripción

PreInit (nuevo)

Se ejecuta antes de iniciar todo el proceso de ejecución de la página.

Init

Inicia el proceso.

InitComplete

Se ejecuta cuando el proceso de inicialización finaliza.

PreLoad

Se ejecuta antes de que la información de estado sea leída.

Load

Se ejecuta luego de leer la información de estado.

LoadComplete

Se ejecuta al finalizar la carga y ejecución de la página.

PreRender

Antes de comenzar a renderizar (generar el HTML) de la página. Luego de PreRender y de que todos los controles hijos hayan sido creados. Último evento antes de cerrar la ejecución.

PreRenderComplete UnLoad

Servicios Los servicios y APIs disponibles al programador también han evolucionado. Ahora disponemos de hip para la istración de s registrados en nuestro sitio Web, istración de roles para el nivel de s, SiteMaps para la istración de la estructura del sitio y 3UR¿OH para la personalización del perfil de cada .

Modelo de Trabajo Para organizar mejor el trabajo, ahora existen distintas carpetas opcionales destinadas a tareas particulares. Recordemos que si estamos trabajando en un sitio Web y no en un Proyecto de Aplicacion Web, cualquier archivo en la carpeta es parte del proyecto. Visual Studio - Firtman, Natale

Alfaomega

216

6- ASP.NET

La estructura de cualquier sitio Web ASP.NET podría ser la siguiente: Carpeta

Función

\

Carpeta raíz y ubicación de los archivos.

\bin

Contiene todos los assemblies precompilados.

\App_code

Contiene código fuente en archivos .vb o .cs que ASP.NET compila dinámicamente ante cualquier cambio.

\App_GlobalResources

Contiene archivos de recursos (.jpg, .gif, .resx, .xsd) que ASP. NET compila dinámicamente. Son globales a toda la aplicación.

\App_LocalResources

Contiene archivos de recursos (.jpg, .gif, .resx, .xsd) que ASP.NET compila dinámicamente. Pueden ser aplicados a distintas subcarpetas de la aplicación.

\App_Themes

Almacena subcarpetas por cada tema, donde estarán los skins disponibles.

\App_WebReferences

Es un contenedor para archivos relativos a Web Services, como proxies y esquemas.

\App_Data

Carpeta reservada para incluir archivos de datos, como Bases de Access. Ya posee los permisos necesarios.

\App_Browsers

Definición de navegadores Web para que ASP.NET los reconozca y detecte sus capacidades.

Fig. 6-3. En ASP.NET existe una estructura de directorios bien definida para algunas funciones propias de la plataforma. Alfaomega


Fundamentos

217

Las extensiones más comunes de archivos disponibles en cualquier aplicación ASP.NET son las siguientes: Extensión

Función

.aspx

Contiene Formularios Web.

.ascx

Contiene Controles Web Personalizados.

.ashx

HTTP Handlers.

.asix

Imagen Dinámica.

.asmx

Contiene definición de un Web Service.

.master

Contiene una Página Maestra.

.skin

Contiene información sobre un Skin para Themes.

.resx .resource FRQ¿J

Contiene archivos de recursos.

.sitemap

Contiene un mapa jerárquico XML representando la estructura del sitio.

.edmx

Modelo Entity Framework.

.xsd

DataSet.

.svc

Servicio de Datos de ADO.NET o WCF.

.dbml

Modelo de datos de LINQ To SQL.

.js

Archivo JavaScript. Incluye controles para ASP.NET AJAX,

Contiene archivos de recursos. Es un archivo de configuración XML.

Fig. 6-4. Al crear un nuevo archivo en Visual Studio, en un proyecto ASP.NET, encontramos diversas opciones. Visual Studio - Firtman, Natale

Alfaomega

218

6- ASP.NET

En ASP.NET podemos trabajar con dos modelos: Code-Inside (también llamado Code-Beside) y Code-Behind. En el primero de ellos, el código de servidor está incluido en el archivo .aspx dentro de etiquetas <script runat=”server”>. En Code-Behind, el código de servidor está en un archivo separado (generalmente, .aspx.vb o .aspx.cs) y en Visual Studio este modelo es el más cómodo y más utilizado de los dos.

Fig. 6-5. En Visual Web Developer o Visual Studio al crear un nuevo ítem Webform, estamos trabajando en modo Code-Inside, a no ser que seleccionemos la casilla “Colocar el codigo en un archivo independiente”.

Gracias a las clases parciales, una página ASPX en Code-Behind termina siendo una clase parcial definida en dos archivos .aspx y .aspx.cs, por ejemplo. La ventaja es que ya no hace falta tener información duplicada acerca de los controles Web en ambos archivos para garantizar que todo funcionará correctamente. Es así que, al usar Code-Behind, en C# los archivos quedarían separados de la siguiente forma: CodeBehind.aspx <%@ Page Language="C#" AutoEventWireup="true" CodeFile="CodeBehind.aspx.cs" Inherits="CodeBehind" %>

Alfaomega


Fundamentos

219

CodeBehind.aspx.cs public partial class CodeBehind : System.Web.UI.Page { }

De esta forma podemos ver que utiliza el concepto de clases parciales visto anteriormente, lo que define que, en realidad, el .aspx y el .aspx.cs (o .aspx.vb) son la misma clase, una expresada en lenguaje C# (o VB) y la otra en XML, que sabemos que termina definiendo objetos disponibles e instanciados en la página.

Configuración Primero analicemos :HEFRQ¿Jpara ver las configuraciones más utilizadas que actualmente soporta y, luego, veremos la nueva interfaz de configuración que nos provee ASP.NET. Sección

Descripción

DQRQ\PRXV,GHQWL¿FDWLRQ

Permite controlar cómo se istran los s anónimos en Profile.

authentication

Controla la autenticación de s en la aplicación.

authorization

Controla la autorización de a distintas URLs según los privilegios del .

browserCaps

Definición de capacidades de browsers.

caching

Control de Caché en ASP.NET.

compilation

Opciones de compilación.

customErrors

Permite personalizar los mensajes de error http.

globalization

Definición para seteos de globalización.

healthMonitoring

Monitorea el servidor por eventos excepcionales y define cómo actuar ante ellos.

hostingEnvironment

Define propiedades del entorno del servidor.

httpCookies

Cómo ASP.NET controla las cookies en funciones propias de la plataforma

httpModules

Configura módulos HTTP.

httpHandlers

Responsable de mapear URLs a clases que implementen IHttpHandler.

httpRuntime

Configura el entorno de ejecución.

identity

Define la identidad de Windows que se ha de usar.

machineKey

Guarda la clave de encriptación.

hip

Configura proveedores para el sistema de membresía.


Alfaomega

220

6- ASP.NET

mobileControls

Configura los controles móviles y adaptadores.

pages

Definiciones para las páginas ASP, como opciones por defecto en las directivas.

processModel

Configura el modelo de proceso de ASP en IIS.

SUR¿OH

Define opciones para el sistema de Perfiles de ASP.

roles

Configura el de roles.

sessionPageState

Configura cómo el estado de sesión se utiliza para el viewstate en equipos móviles.

sessionState

Define el módulo de sesión.

sitemap

Configura información sobre el sistema de navegación.

trace

Servicio de Trace.

trust

Define el nivel de confianza que se ha de utilizar al ejecutar aplicaciones ASP.NET.

urlMappings

Configura mapeos URL para el sistema de navegación.

WebParts

Define el sistema de Web Parts.

WebServices

Configura los servicios Web.

xhtml11Conformance

Controla el nivel de uso de los estándares XHTML en los controles Web.

Asistentes de configuración Además de configurar manualmente el sitio Web, editando asimismo el archivo :HEFRQ¿J, ASP.NET trae consigo otros métodos más fáciles de utilizar y definir la configuración de un sitio Web. El primero de ellos es la consola de istración ASP.NET MMC (Microsoft Management Console Snapin). Esta consola se integra a la del Internet Information Server. Para utilizarla, los pasos son los siguientes: s Abrir la consulta del Internet Information Server en de Control, Herramientas istrativas, Servicios de Internet Information Server. s

Elegir la carpeta o aplicación que se ha de configurar.

s

Seleccionar Propiedades.

s

Seleccionar la sección ASP.NET.

s

Seleccionado Editar Configuración, se nos abrirá una nueva ventana para inspeccionar y modificar distintas opciones propias del :HEFRQ¿J en una interfaz más fácil.

Alfaomega


Fundamentos

221

Fig. 6-6. Una de las opciones para configurar la aplicación Web sin tener que editar a mano el archivo :HEFRQ¿J es a través de la consola ASP.NET MMC Snapin.

Otra opción es utilizar el Web Application istration Tool, que es una interfaz Web para configurar todo lo referente a la aplicación ASP.NET. Para utilizarlo, desde Visual Web Developer Express o Visual Studio (en un proyecto Web), en el menú Sitio Web encontraremos la opción &RQ¿JXUDFLyQGH$631(7. Esta opción nos abrirá una página Web en el mismo explorador Web del entorno.

Fig. 6-7. Aquí vemos a Visual Web Developer con el Web, donde podremos configurar ASP.NET desde la misma interfaz en el proyecto Web que tenemos abierto. Visual Studio - Firtman, Natale

Alfaomega

222

6- ASP.NET

Desde aquí podremos configurar: s s s s s s

Autenticación, autorización y seguridad de las aplicaciones. Un servidor SMTP para envío de e-mails. istrar variables de servidor. istrar s y roles habilitados en el sitio Web. Definir páginas personalizadas de error. Dejar off-line una aplicación temporalmente.

Muchas de estas acciones requieren que se haya definido una base de datos SQL Server para trabajar. En estos casos, automáticamente la plataforma creará todas las estructuras que necesita para cada opción. Existe una utilidad de línea de comandos, llamada aspnet_regiis, que permite instalar ASP.NET en IIS, instalarlo en una aplicación específica o cambiar la versión de .NET utilizada. Con aspnet_regiis -? obtenemos todos los comandos.

Fig. 6-8. En la sección aplicación del sistema de configuración, podemos dejar offline la aplicación, cambiar datos de debugging y definir opciones de configuración.

Pequeños cambios, grandes soluciones Ahora veamos pequeños cambios que han incorporado al desarrollo de aplicaciones Web y que nos permitirán solucionar rápidamente muchas cosas. Alfaomega


Fundamentos

223

ControlState El famoso ViewState, el código que permite almacenar valores y el estado de los controles entre Postbacks, sigue vigente en ASP.NET; pero dado que en repetidas oportunidades genera muchos kilobytes de información, numerosos desarrolladores lo desactivan. Asimismo, existe cierta información crítica para el buen funcionamiento de la plataforma ASP.NET, que se necesita igualmente mantener. Por ello, han separado esta información crítica en otro objeto llamado ControlState, que no puede desactivarse. Foco Comenzamos con la posibilidad de definir dónde queremos que el foco del cursor se pose al comenzar la aplicación o luego de un Postback. De esta forma, cuando un ingresa mal algún dato, podemos automáticamente ubicar el cursor en el lugar necesario para que haga el arreglo. Para ello, todos los controles tienen el método Focus. Siguiendo con el tema del foco de los controles, ahora la etiqueta

de cualquier formulario Web posee dos propiedades adicionales: defaultbutton y defaultfocus. La primera de ellas soluciona un problema muy común en aplicaciones ASP.NET 1.x. ¿Qué pasa cuando el presiona Enter en un formulario? En ASP.NET 1.x no pasaba nada, dado que el no había utilizado ningún control válido. Ahora, podemos deﬁnir en defaultbutton el id del botón que será invocado cuando el pulse Enter. La propiedad defaultfocus indicará el nombre del control que tendrá el foco al cargarse la aplicación.

Fig. 6-9. Cuando tenemos dos formularios conceptuales, dentro de una misma página, la agrupación de validadores nos permite trabajar con validación separada por cada uno de ellos. Visual Studio - Firtman, Natale

Alfaomega

224

6- ASP.NET

Por ejemplo:

La vida del foco de los controles en ASP.NET continúa y ahora todos los validadores tienen la propiedad lógica SetFocusOnError que, en caso de estar en True, posará al en el control que no ha pasado la validación. Navegación Cruzada Todos pensamos en el postback como la acción de enviar datos y recargar la misma página en la que estamos trabajando. Pero ASP.NET ahora nos trae una nueva opción: Podemos hacer un postback hacia otra página. ¿Es entonces un hipervínculo? No, analicémoslo un poco mejor. Es común en páginas ASP.NET 1.0 que, para utilizar todas las ventajas del modelo y no recurrir a variables de sesión o parámetros GET entre links, tengamos enormes formularios Web con cientos de controles y es, que vamos activando o desactivando según la funcionalidad. Ahora tenemos una nueva opción, es decir, utilizar distintos formularios Web pero vinculados de una forma que acompaña el modelo de desarrollo ASP. Todos los controles que generen algún tipo de PostBack (botones, listas de opciones, opciones de selección, etc.) tienen la propiedad opcional PostBackUrl, que indica el nombre de un formulario Web (dentro de la misma aplicación ASP) adónde dirigir la ejecución cuando se accione dicho evento. Ahora bien, ¿cómo accedemos desde la segunda página a los valores de los controles que dejó el en la primera? Veámoslo con un ejemplo: Pagina1.aspx <%@ Page Language="VB" %>

Alfaomega


Fundamentos

225

Pagina2.aspx <%@ Page Language="VB" %> <%@ PreviousPageType VirtualPath="~/Pagina1.aspx" %> <script runat="server"> Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) 9HUL¿FDPRVTXHH[LVWDODSiJLQDSUHYLD If PreviousPage IsNot Nothing Then 9HUL¿FDPRVTXHKD\DVLGRXQSRVWEDFNFUX]DGR 'Si es falso, puede ser un Server.Transfer If PreviousPage.IsCrossPagePostBack Then Response.Write("PostBack") 3RGHPRVXVDUDWULEXWRV\PpWRGRVGHODSiJLQD 'anterior VyORVLORVKHPRVGHFODUDGRFRPRS~EOLFRV Else Response.Write("Viene de Server.Transfer") End If Else Response.Write("Ingreso Directo") End If End Sub

Aquí vemos que el objeto Page tiene una nueva propiedad (de clase Page también) y es PreviousPage, que tiene una instancia sólo si ha existido un postback cruzado o si el ha llegado a la página por una sentencia Server.Transfer. Para saber si se trata de un postback, existe la propiedad IsCrossPagePostback. Veamos como importante que la segunda página tiene una nueva directiva de página, PreviousPageType. Si no se la coloca, el postback cruzado funcionará igual, pero perderemos todo soporte de Intellisense y debugging en Visual Studio, dado que no sabrá a qué página refiere el objeto PreviousPage. Si tenemos varias páginas que hacen un postback cruzado, podemos saber cuál es consultando las propiedades de PreviousPage, como AppRelativeVirtualPath. Si quisiéramos entonces acceder a datos o controles de la primera página, deberíamos haber colocado en Pagina1.aspx el siguiente código Visual Basic (igual sería en C#): <script runat="server"> Public ReadOnly Property txtNombre() As TextBox Get 'Devuelve la instancia del control Visual Studio - Firtman, Natale

Alfaomega

226

6- ASP.NET

Return txtNombre End Get End Property

Y en la página destino, entonces, podríamos acceder al texto que ingresó el en la inicial, utilizando: PreviousPage.txtNombre.Text

Directorio raíz de la aplicación En cualquier propiedad de cualquier etiqueta donde necesitemos referenciar a un archivo de nuestra aplicación, podemos utilizar el símbolo ~ para definir el directorio raíz, como ser PostBackUrl=”~/Pagina2.aspx”. Validación en Grupos En ASP.NET 1.x podíamos tener distintos controles de ingreso y distintos controles de validación, que verificaran que los datos de ingreso concuerden con ciertas reglas. Ahora bien, supongamos que en un mismo formulario Web, tenemos un cuadro de búsqueda y, al mismo tiempo, un formulario de ingreso de datos. Si todo tiene validación, al querer hacer una búsqueda nos va a pedir que también los controles del formulario de ingreso de datos pasen la validación. Por eso, desde ASP.NET 2.0 ahora tenemos grupos de validación. De esta forma, cada control de tipo botón ahora tiene la propiedad ValidationGroup, que permite definir un nombre de grupo. Esta propiedad también debe ser definida, al mismo tiempo, en el control de validación; de esta forma, cada control de validación actuará solamente si el grupo al que pertenece es el mismo que el grupo al que pertenece el botón que el ha ingresado. Veamos un ejemplo:

Visual Studio .net Framework 3.5 Para Profesionales - Maximiliano Firtman-librosvirtual.pdf 312v32

Overview 4q3b3c

More details 26j3b

Clientes k1o2q

<%# Eval("Nombre") %> 5tr6p

Conversor de Temperaturas 1e5a2k

Index j3043

Nuevo Cliente i194d

<%= ViewData("titulo") %> 2921x

Related Documents 171j1w

Visual Studio .net Framework 3.5 Para Profesionales - Maximiliano Firtman-librosvirtual.pdf 312v32

Visual Studio .net 6c1s5p

Guia Visual Studio Net 195n4c

Net Framework 4y2h72

.net Framework 6o203t

Guia De Ejercicios Visual Studio .net d3qr

More Documents from "Nicolás Ron" 452445

2c82t

Como Convertir Un Documento A Pdf Yahoo i6v3a

Examination Paper Of Cbse Class Xii 341g3v

Presupuesto Logistico 3l1m13

2c82t

Como Convertir Archivo Word Para Pdf 1x657