PPT's de las sesiones de ASP.NET Connections: WPF/E, LINQ y ASP.NET Tips/Tricks

Esta semana di tres sesiones en la conferencia ASP .NET Connections en Orlando. Abajo tenéis las trasparencias / demos de cada una de las sesiones:

Introducción a “WPF/E”

Esta charla es una, creo que, buena introducción a “WPF/E” – es el nombre en clave de una nueva plataforma que permitirá a los desarrolladores y diseñadores crear webs más ricas y más interactivas, todo para mejorar la experiencia del usuario. Aquí teneis mi primer post sobre “WPF/E”.

Aquí teneis las ppt’s y las demos de esta charla. (Hay un video de ejemplo, por eso ocupa 10MB). En la charla expliqué las principales capacidades que tiene la CTP de WPF/E, y también mostré los conceptos sobre XAML y JavaScript que usaremos.

Para ver más ejemplos de “WPF/E” pasad por la galería de ejemplos de “WPF/E” en Channel9 aquí. También os podéis descargar documentación y ejemplos de la web oficial en MSDN aquí. Mike Harsh también mantiene un blog fantástico sobre WPF/E aquí, os recomiendo que os subscribáis.

Construyendo aplicaciones Web con LINQ.

En esta charla mostramos en detalle LINQ (que será incluido en la release “ORCAS”) y demostramos algunos de los incrementos de productividad que le dará a ASP.NET. Clic aquí para descargar las ppt’s.

Si aún no lo habéis visto, os recomiendo que veáis este video de 20 minutos donde enseñamos el uso de LINQ en Visual Studio “Orcas”, aquí. Podéis aprender más sobre LINQ y cómo usarlo en ASP .NET si le echáis un vistazo a los post anteriores sobre LINQ. Aquí tenéis unos cuantos enlaces de interés.

Finalmente, para aprender más sobre las nuevas características de los lenguajes C# y Visual Basic que van a venir con Orcas (LINQ se basa en ellas) echadle un vistazo a los dos primeros post de la serie de articulos que estoy escribiendo:

Voy a escribir un nuevo artículo de esa serie, hablará sobre Lambda expressions.

ASP.NET 2.0 Tips and Tricks:

Esta sesión cubre ASP.NET UI, AJAX, caching y trucos de despliegue, y trucos de Visual Studio 2005. Los ejemplos se han hecho con versiones actualizadas de ASP.NET AJAX funcionan con ASP.NET AJAX 1.0. Os podeis descargar las ppt’s y las demos aquí.

Podeis aprender más sobre la optimización del rendimiento de la compilación de Visual Studio leyendo estos post.

Espero que os haya gustado.

Scott.

 Traducido por: Juan María Laó Ramos. Microsoft Student Partner.

Desarrollo de juegos con XNA

La última vez que desarrollé un videojuego fue en los 80 con un Commodore 64. Las cosas han cambiado un poco desde entonces, y la última release de XNA me ha dado la oportunidad de pasearme por todo eso del desarrollo de juegos y ver cómo es XNA.

¿Porque XNA?

El desarrollo de juegos es un Gran Negocio – Según algunas fuentes, el juego “GoldenEye” ha dado más dinero que la propia película y costó muchísimo menos producirlo. Pero a la vez, la rentabilidad está amenazada, secuelas, packs de expansión, licencias, etc, no hay nuevas ideas.

¿La razón? El desarrollo es caro. No sólo en líneas de código, sino por la cantidad de recursos que se necesitan –  diseñadores gráficos, músicos, etc. Cuesta alrededor de 10 millones de dólares y equipos de más de 30 personas. Cuesta demasiado crear y distribuir un juego.

Los juegos de bajo coste pueden distribuirse a traves de Xbox Live Arcade y comprarse en los Microsoft Points. Esto está bajando el listón de entrada en el mercado para este tipo de juegos.

¿Qué es XNA?

El XNA Framework permite crear juegos modernos usando el lenguaje de programación C# y un gran conjunto de librerías de desarrollo. El XNA Framework provee de su propio pipeline para que sea más fácil obtener contenidos ricos (3D, 2D, sonido, etc)  de las fuentes necesarias para introducirlas en un juego. Provee un gran nivel de unificación de API’s para implementaciones en Windows y 360, eliminando virtualmente el coste y esfuerzo necesario para portar juegos entre esas dos plataformas” (De la web de XNA).

XNA viene de XNA’s Not Acronymed :-). Requiere Visual C# Express 2005 y XNA Game Studio Xpress, y una cuenta XNA Creators Club para la Xbox 360.

XNA en Windows es un conjunto de librerías echas sobre el .NET Framework 2.0. Y en la Xbox 360 usa una implementación nativa del CLR de .NET Compact Framework 2.0.

Los juegos desarrollados con XNA Game Studio Express están limitados para uso no comercial en Xbox 360, pero para Windows si está permitido. XNA Games Studio Professional permitirá a los desarrolladores crear juegos comerciales para la Xbox 360 y saldrá al mercado próximamente.

Programando en XNA.

Una aplicación estructurada permite un comienzo estructurado. En el bucle Update pondremos la lógica del juego: mover objetos, control del usuario, decidir la colisión de objetos, y un largo etcétera. En el bucle Draw renderizaremos los objetos y los fondos de la pantalla, etc.

Así que el modelado 2D y los sprites están de vuelta – algo que ya tenía el Commodore 64.

El sonido es a través del Microsoft Cross-Platform Audio Creation Tool (XACT) para trabajar con motores de audio, bancos Wave, de sonido.

También hay clases para manejar los dispositivos de entrada de la Xbox 360, teclado, raton, gatillos, disparadores y para tratar las entradas analógicas y digitales.

Recursos de interés:

http://msdn.microsoft.com/xna/

http://blogs.msdn.com/xna/

http://learn-xna.com/

http://www.xnatutorial.com/

Traducido por: Juan María Laó Ramos. Microsoft Student Partner.

Actualizaciones en la documentación de AJAX

>Os pongo un pequeño post sobre contenidos de ASP .NET AJAX que han sido publicados recientemente:

ASP.NET AJAX Documentation Update.

El equipo de documentación ASP.NET ha actualizado la documentación de ASP.NET AJAX 1.0. Haz clic aquí para verlo o descargártelo.

Un pequeño resumen de algunas de las mejoras:

          Actualizadas 38 descripciones y tutoriales que incluyen comentarios, información adicional y se han corregido algunos errores.

          U nuevo tema sobre compatibilidad de exploradores y opciones de seguridad para sitios webs con AJAX.

          Dos nuevos temas para eventos del ciclo de vida de clientes ASP.NET AJAX.

          Se han actualizado 243 referencias con preguntas  de clientes, sugerencias y feedback.

          14 nuevos temas sobre la generación de las clases proxy.

          Se han actualizado 165 code snippets para clarificar patrones de codificación, añadido sugerencias y se han corregido errores.

          Se han añadido 61 code snippets nuevos.

Nuevos videos de ASP .NET AJAX “How do I?”

Joe Stagner del equipo de ASP .NET sigue publicando nuevos videos “How do I?” sobre ASP.NET AJAX (son todos gratuitos).

Os pongo algunos de esos nuevos videos:

actualizacionesajax1Tenéis todos los videos aquí.

Cómo construir un sitio como PageFlakes.com con ASP.NET AJAX.

Omar Al Zabir es el cofundador y CTO de www.PageFlakes.com – un sitio “cool” para la web 2.0 (que además ha sido creado usando ASP .NET AJAX).Escribió un gran artículo sobre cómo construir un portal personalizado que permita drag&drop desde el lado cliente y personalización por usuario.

ActualizacionesAJAX2

Podéis leer el artículo sobre cómo hacer un sitio como el de arriba usando ASP.NET AJAX 1.0 y bajaros el código de ejemplo desde aquí.

Post sobre ASP.NET AJAX en el blog de Elion.

Elion Lipton es uno de los principales desarrolladores del equipo de ASP .NET, y tiene un blog increíble aquí. Tiene una serie de artículos recientes sobre ASP.NET AJAX para leer:

ActualizacionesAJAX3

Posts sobre ASP .NET AJAX de Bertrand.

Bertrand Le Roy es otro de los principales desarrolladores del equipo ASP.NET, y también representa a Microsoft en la alianza de OpenAJAX. Su blog aquí.

Ha escrito unos cuantos post de obligada lectura sobre ASP.NET AJAX:

Bertrand ha escrito un libro en pdf con Matt Gibbs que podeis descargaros a través de la serie de Short Cuts de O’Reilly. Se llama “ASP .NET AJAX UpdatePanel Control” y (sorpresa) trata sobre cómo usar el control UpdatePanel. Aquí lo teneis.

Ejemplo de Drag-Drop de Jeff Prosise.

Jeff ha escrito un post sobre cómo implementar un sencillo drag/drop en cliente con la librería de JavaScript ASP.NET AJAX. Podéis leerlo aquí.

Espero que os haya gustado.

Scott  Traducido por: Juan María Laó Ramos. Microsoft Student Partner.

 

Nueva característica de “Orcas”: Métodos de extensión.

(en Ingles: Extension Methods)

La semana pasada empecé una serie de post en el blog en los que cubriré algunas de las nuevas características de VB y C# que van a venir con la nueva release de Visual Studio y el .NET Framework.

En mi último post hablé sobre las Propiedades Automáticas, Inicializadores de Objetos e Inicializadores de Colecciones. Si aún no lo habéis leído, podéis leerlo aquí. El post de hoy va sobre una nueva característica que viene tanto en VB como en C#. Métodos de extensión.¿Qué son los métodos de extensión?

Los métodos de extensión permiten a los desarrolladores añadir nuevo métodos al contrato público de un tipo ya existente en el CLR, sin tener que recompilar el tipo original. Los métodos de extensión permiten mezclar la flexibilidad del soporte “duck typing” de los lenguajes dinámicos de hoy con el rendimiento y la validación en tiempo de compilación de los lenguajes fuertemente tipados.

Los métodos de extensión posibilitan la aparición de una gran variedad de escenarios , y ayudan a hacer posible el poder del framework LINQ que va a ser añadido a .NET como parte de la release de Orcas.

Ejemplo de un método de extensión simple:

¿No habéis querido chequear si un string es una dirección válida de email? Hoy, implementaríamos esto llamando a una clase a parte (seguramente con un método estático) para ver si el string es válido. Por ejemplo, algo así:

string email Request.QueryString[“email”];if ( EmailValidator.IsValid(email) ) {
   

}

Usando métodos de extensión podríamos añadir un método “IsValidEmailAddress()” dentro de la propia clase string, y devolverá cierto o falso dependiendo de si la dirección es válida o no. De esta forma, podríamos hacer lo de arriba con el siguiente código:

string email Request.QueryString[“email”];if ( email.IsValidEmailAddress() ) {
   

} 
 

Pero, ¿cómo añadimos este nuevo método, IsValidEmailAddress(), a la clase string?. Lo hicimos definiendo una clase estática con un método estático que contiene nuestro método de extensión IsValidEmailAddress() de la siguiente forma:

public static class ScottGuExtensions
{
    
public static bool IsValidEmailAddress(this string s)
    {
        Regex regex 
= new Regex(@”^[w-.]+@([w-]+.)+[w-]{2,4}$”);
        return 
regex.IsMatch(s);
    
}
}

Daros cuenta que en el parámetro de entrada del método está la palabra “this”, antes que el parámetro de tipo string. Esto le dice al compilador que este método de extensión debe ser añadido a objetos de tipo  string. Dentro del cuerpo del método IsValidEmailAddress() podemos acceder a todas las propiedades/métodos/eventos públicos de la instancia del string actual, y devolver true/false dependiendo de si es un email válido o no.

Para añadir este método de extensión específico a las instancias de string de mi código, sólo usamos un “using” estándar para importar el namespace que contiene la implementación de los métodos de extensión:

using ScottGuExtensions;

El compilador resolverá correctamente el método IsValidEmailAddress() en cualquier string.  C# y VB dan soporte completo para el intellisense de los métodos de extensión en el editor de Visual Studio. De manera que cuando pulsamos el “.” en una variable string, los métodos de extensión que hayamos implementado, se mostrarán en la lista del intellisense.

IntelliSense

Los compiladores de VB y  C# dan soporte para el chequeo en tiempo de compilación del uso de métodos de extensión.

[Creditos: Gracias a David Hayden por su primera aproximación al escenario de IsValidEmailAddress de ántes por su post sobre el tema el año pasado.

Continuación de los escenarios para métodos de extensión…

Centrándonos en los métodos de extensión para añadir métodos a tipos existentes, podemos abrir una gran variedad de escenarios posibles para los desarrolladores. Lo que realmente hace a los métodos de extensión una herramienta prodigiosa no es sólo poder ser aplicada a tipos individuales, sino a cualquier clase padre o interface del .NET Framework. Esto permite a los desarrolladores construir una variedad casi infinita de extensiones que se pueden usar en todo el .NET Framework.

Por ejemplo, imaginemos que quiero comprobar de forma fácil y descriptiva si un objeto está añadido en una colección o array de objetos. Podemos añadir un simple método de extensión .In(collection) que quiero que se añada a todos los objetos de .NET para poder hacer eso. Podemos implementar este método de extensión “In()” en C# de la siguiente forma:

Extensionmethod

Fijaos cómo he declarado el primer parámetro para el método de extensión es “this object o”. Esto indica que este método de extensión debe ser aplicado a todos los tipos que hereden de la clase base System.Object – esto significa que puedo usar este método en cualquier objeto en .NET.

La implementación del método “In()”  de arriba, nos permite ver si un objeto específico está incluido en una secuencia IEnumerable que se le pasa como argumento. Debido a que todas las colecciones de .NET implementan la interfaz IEnumerable, hemos conseguido un método útil y descriptivo para comprobar si cualquier objeto de .NET pertenece a cualquier colección o tabla de .NET.

Podemos usar este método de extensión “In()” para comprobar si un string en particular está en un array de strings:

ExtendionMethod2

Incluso podemos comprobar si un control de ASP .NET está en un contenedor de controles:

Extension method Controls

Hasta podemos usarlos con tipos escalares como enteros:

Extension methods valores escalares

Daos cuenta de que podemos usar estos métodos de extensión hasta en valores de los tipos base (como el entero 42). Ya que el CLR soporta el boxing/unboxing automático  de clases valor, los métodos de extensión se pueden aplicar a números y otros tipos de datos escalares directamente.

Como podéis empezar a discernir de los ejemplos de arriba, los métodos de extensión nos abren escenarios muy ricos y posibilidades de extensibilidad. Cuando se aplican a clases comunes y a interfaces en .NET nos habilitan frameworks de dominio específicos muy curiosos.

Sistema empotrado. Métodos de extensión de Linq.

Una de las librerías de métodos de extensión que estamos metiendo en .NET en Orcas, son un conjunto de métodos de extensión que permiten a los desarrolladores hacer consultas sobre datos. Estas implementaciones están en el namespace “System.Linq”, y definen un sistema de consultas estándar para ser usado por cualquier desarrollador de .NET para consultar archivos XML, bases de datos relacionales, objetos .NET, y/o otro tipo de estructura de datos.

Algunas de las ventajas de usar el modelo de extensibilidad de consultas son:

1)      Provee un modelo de programación de consultas y una sintaxis que puede ser usada para todos los tipos de datos (bases de datos, archivos XML, objetos en memoria, servicios web, etc).

2)      Permite a los desarrolladores añadir nuevos métodos y operadores en la sintaxis de las consultas. Por ejemplo: podríamos usar nuestro método “In()” junto al estándar “Where()”  definido por LINQ como parte de una consulta simple. El método “In()” parecerá tan natural como los métodos “estándar” en el namespace System.Linq.

3)      Es extensible y permite que podamos usar cualquier tipo de proveedor de datos. Por ejemplo: un motor ORM como NHibernate o LLBLGen podrían implementar los operadores del estándar LINQ para permitir consultas LINQ en esas implementaciones de ORM y motores de mapeo. Esto permitirá a los desarrolladores aprender una forma común de consultar datos, y aplicar las mismas habilidades sobre una gran variedad de implementaciones de salvaguarda de datos.

Escribiré mucho sobre LINQ en las próximas semanas, pero quería dejaros un par de ejemplos para mostrar cómo usar alguno de los métodos de LINQ con diferentes tipos de datos:

Escenario 1: Usando Linq sobre objetos de .NET en memoria.

Supongamos que hemos definido la clase “Person” de la siguiente manera:

clase person

Podemos usar los nuevos inicializadores de objetos y de colecciones para crear una colección “people” así:

Lista de person

Podríamos usar el estándar “Where()” de LINQ para obtener una secuencia de los objetos de tipo “Person” cuyos nombres empiezan por S:

Linq1

La nueva sintaxis => es un ejemplo de las expresiones Lambda, que son una evolución de los métodos anónimos de C# 2.0, y nos permite expresar fácilmente un filtro con un argumento (en caso de que estemos indicando que sólo queremos devolver una secuencia con los objetos Persona cuya propiedad FirstName empiecen con la letra “S”). La consulta anterior devolvería 2 objetos como parte de la Secuencia (por Scott y Susanne).

Podemos escribir un código que use las ventajas de los métodos “Average” y “Max” que nos aporta System.Linq para determinar el promedio de edad de nuestra colección de personas, así como la edad mayor:

Linq2

Escenario 2: Usando LINQ sobre archivos XML

Probablemente sea raro que creemos una colección de datos en memoria manualmente. Lo más común es que obtengamos esos datos de un archivo XML, una base de datos o un servicio web.

Supongamos que tenemos un archivo XML en el disco con los siguientes datos:

Linq&XML

Obviamente podemos usar la API de System.XML para cargar el archivo en un DOM y acceder a él, o usar la API XmlReader para parsearlo manualmente. Pero con Orcas podemos usar la implementación de System.XML.Linq que soporta el estándar de extensión de métodos LINQ para parsearlo y procesarlo más elegantemente.

El código de abajo nos muestra cómo usar LINQ para obtener todos los objetos de los elementos XML <person> que tienen un subnodo <person> cuyos valores internos empiezan con la letra “S”:

Linq&XML2

Daos cuenta que su uso es igual que el método de extensión Where() del ejemplo del objeto en memoria. Ahora vamos a devolver una secuencia de elementos “XElement”, un tipo no-tipado de un nodo XML. Podemos reescribir la consulta de forma que nos devuelva los datos usando el método Select() de LINQ y crear una expresión Lambda que use la sintaxis de inicializadores de objetos para calcular la misma clase “Person” que usamos en el primer ejemplo:

Linq&XML3

El código anterior hace todo el trabajo necesario para abrir, parsear y filtrar el XML del archivo “test.xml”, y nos devuelve una secuencia fuertemente tipada de objetos Person. No hace falta ningún mapeado para los valores – estamos expresando la transformación XML -> objeto directamente con la consulta de LINQ.

Incluso podríamos usar los mismos métodos de LINQ: Average() y Max() para calcular el promedio de edad de los elementos <person> del archivo XML y la mayor edad:

linqXML4

No tenemos que parsear manualmente el archivo XML. No sólo XLINQ hará esto por nosotros, sino que además parseará el archivo usando XMLReader y no tendrá que crear un DOM para evaluar las expresiones de LINQ. Esto se traduce en mayor velocidad y bajo consumo de memoria.

Escenario 3: Usando LINQ sobre bases de datos.

Supongamos que tenemos una base de datos que contiene una tabla llamada “People” y que tiene el siguiente esquema:

LINQ&DDBB

Podemos usar el nuevo diseñador LINQ to SQL WYSIWYG ORM de Visual Studio para crear rápidamente una clase “Person” que mapee la base de datos:

linq&ddbb2

Podemos usar el mismo método de LINQ Where() que usamos para los objetos y el XML para obtener una secuencia fuertemente tipada de objetos “Person” de la base de cuyo nombre comience por “S”:

linq&ddbb3

Fijémonos en que la sintaxis es la misma que la de los objetos en memoria y para el archivo XML.

Podemos usar los métodos de LINQ: Average() y Max() para obtener el promedio y la edad máxima:

linq&ddbb4

No hay que escribir ningún código SQL. El mapeador relacional LINQ to SQL que viene con Orcas se encargará de obtener, rastrear y actualizar objetos que se mapeen con el esquema de nuestra base de datos y/o SPROC’s. Podemos usar LINQ para filtrar los resultados, y LINQ to SQL ejecutará el código SQL necesario para obtener los datos (Nota: Los métodos Average y Max no devolverán todas las filas de la tabla, obviamente – sino que usara las funciones necesarias de TSQL para calcular los valores de la base de datos y devolver resultados escalares).

Ved este video que gravé en Enero para ver cómo LINQ to SQL aumenta la productividad de datos en Orcas. En el video también podéis ver el nuevo diseñador LINQ to SQL WYSIWYG ORM en acción, así como el intellisense del editor de código cuando escribimos código LINQ sobre el modelo de datos.

Resumen

Este post nos da una base para entender cómo funcionan los métodos de extensión, y algunas de las cosas que se van a poder hacer con él. Como cualquier método de extensibilidad, no he querido saturaros creando nuevos métodos de extensión. Y es que, ¡aunque tengas un nuevo martillo no significa que todo en el mundo se haya convertido en una nuez.!

Si os queréis iniciar probando métodos de extensión os aconsejo que le echéis un vistazo a los operadores estándar de consultas que vienen en System.Linq en Orcas. Nos dan soporte sobre arrays, colecciones, stream de XML, o bases de datos, y pueden incrementar extraordinariamente vuestra productividad cuando trabajáis con datos. Os daréis cuenta de que reducirán significativamente la cantidad de código que tenéis que escribir en vuestras aplicaciones, y os permitirá escribir código limpio y descriptivo. También tendréis intellisense automático y checking en tiempo de compilación de consultas lógicas en vuestro código.

En las próximas semanas seguiré esta serie de post en las características de tipos anónimos e interfaces anónimas, y seguiré hablando sobre Lambda y otra cosas. Obviamente hablaré un montón sobre LINQ.

Espero que os haya gustado.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner.

Nuevas características de la nueva versión de C# Orcas

La semana pasada lanzamos la versión release de la CTP de Marzo de Visual Studio y .NET Framework “Orcas”. Está disponible para libre descarga en dos versiones, una en VPC ( que permite ejecutarlo en una máquina virtual) y otra como un instalador común (nota: si estáis usando Vista debéis aseguraros de descargaros la versión VPC, para máquinas virtuales). Os la podéis descargar aquí.

Hace unas semanas blogueé  sobre las mejoras (Inglés) para los desarrolladores de ASP .NET que aporta esta release de “Orcas”. Si no habéis leído este post, os lo recomiendo encarecidamente, ya que  creo que os gustarán las nuevas características que trae.

Entre todas las cosas nuevas que aporta el nuevo framework y la herramienta, una de las cosas que creo que les gustará a los desarrolladores (de todos los tipos de aplicaciones .NET) de Orcas son algunas de las nuevas posibilidades que se han añadido a C# y VB. Estos cambios en los lenguajes vienen promovidos para mejorar la experiencia de desarrollo de manera sutil y dramática que mejorarán la productividad y reducirán la cantidad de código que tenemos que escribir.

En las próximas semanas voy a probar y bloguear sobre varias de estas nuevas características de los lenguajes y enseñaré cómo pueden ser usadas para obtener resultados prodigiosos.

Nueva característica de C#: Propiedades automáticas.

Si sois desarrolladores de C#, estaréis acostumbrados a escribir clases con propiedades básicas como en el código siguiente:

public class Person {         private string _firstName;
        private string 
_lastName;
        private int 
_age;
       
        public string 
FirstName {
            
get {
                
return _firstName;
            
}
            
set {
                _firstName 
= value;
            
}
        }
        public string LastName {
            
get {
                
return _lastName;
            
}
            
set {
                _lastName 
= value;
            
}
        }       
       
        
public int Age {
            
get {
                
return _age;
            
}
            
set {
                _age 
= value;
            
}
        }
    }
Daros cuenta de que no estamos añadiendo ninguna lógica en las propiedades Get/Set, todo lo contrario, lo que estamos haciendo es asignar los valores a una variable. La cuestión es ¿entonces porqué no usamos variables en lugar de propiedades? Bueno, hay muchos inconvenientes a la hora de exponer variables públicas. Dos de los problemas más graves son: 1- No podemos hacer un databind de forma fácil sobre variables públicas.2- Si exponemos variables públicas en nuestras clases, más tarde no es posible cambiarlas a propiedades (por ejemplo: para añadir algún tipo de validación en los métodos set) sin tener que recompilar los assemblies que dependan de la antigua clase.El nuevo compilador de C# que viene con Orcas, nos proporciona una forma elegante para hacer que el código que escribamos sea más conciso mientras mantiene la flexibilidad de las propiedades usando una nueva característica conocida como “propiedades automáticas”. Las propiedades automáticas nos permiten evitar la declaración manual de variables privadas y escribir el código de los métodos get/set – En lugar de eso, el compilador puede crear automáticamente las variables privadas necesarias y el código por defecto de los métodos get/set por nosotros.Por ejemplo, usando las propiedades automáticas podemos reescribir el código anterior de la siguiente manera:public class Person {
   
        
public string FirstName {
            
get; set;
        
}         public string LastName {
            
get; set;
        
}       
       
        
public int Age {
            
get; set;
        
}
    }
O si queremos ser más precisos aún, podemos eliminar los espacios en blanco y llegar más lejos de la siguiente forma:

public class Person {
        
public string FirstName { get; set; }
        
public string LastName  { get; set; }       
        
public int    Age       { get; set; }
    }
 Cuando el compilador de Orcas de C# se encuentre con los Get/Set’s vacíos, como en el código anterior, generará automáticamente una variable privada en la clase, e implementará las propiedades públicas get y set para ella. El beneficio de esto es que desde un punto de vista de tipo-contrato, la clase será exactamente igual que la primera implementación de la que hablábamos más arriba. Esto significa que –al contrario que las variables públicas – más adelante podemos añadir validación lógica en el método set sin tener que cambiar ningún componente externo que referencie a mi clase.En Bart De Smet hay una descripción genial sobre qué es lo que pasa por debajo cuando usamos las propiedades automáticas con la CTP release de Marzo de Orcas. Podéis leerlo en este post.Nueva característica en C# y VB: Inicializadores de objetos.Los tipos del .NET Framework confían ciegamente en el uso de propiedades. Cuando instanciamos y usamos clases nuevas, es muy común escribir código como este:      Person person = new Person();
   
person.FirstName “Scott”;
   
person.LastName “Guthrie”;
   
person.Age 32;
¿Habéis querido hacer esto de una forma más clara (o quizás en sólo una línea)?. Con los compiladores de Orcas para C# y VB, podemos usar una característica también genial llamada “inicializadores de objetos” (en ingles: “object initializers”) que nos permite hacer lo que comentamos y reescribir el código anterior de la siguiente forma:  

Person person = new Person { FirstName=“Scott”, LastName=“Guthrie”, Age=32 };  

El compilador generará automáticamente el código de inicialización necesario guardando el mismo significado semántico que en la primera versión (más arriba) del código de ejemplo.Pero no sólo nos permite inicializar un objeto con valores simples, esta nueva característica nos permite poner valores más complejos como propiedades anidadas. Por ejemplo, imaginemos que en la clase Person también tenemos una propiedad llamada “Address” del tipo “Address”. Podríamos escribir el siguiente código para crear un objeto del tipo Person y poner sus propiedades de la siguiente forma:

      Person person = new Person {
      FirstName 
“Scott”,
      LastName 
“Guthrie”
      
Age 32,
      Address 
= new Address {
         Street 
“One Microsoft Way”,
         City 
“Redmond”,
         State 
“WA”,
         Zip 
98052
      
}
   }
;   En Bart De Smet también hay una descripción sobre qué es lo que pasa por debajo cuando usamos los inicializadores de objetos con la CTP release de Marzo de Orcas. Podéis leerlo en este post. Nueva característica en C# y VB: Inicializadores de colecciones de objetos.

Los inicializadores de objetos están bien, y hacen mucho más claro añadir objetos a colecciones de objetos. Por ejemplo, si queremos añadir tres personas a una lista genérica de tipo Person. Podemos escribirlo de la siguiente forma:

  List<Person> people = new List<Person>();
           
  
people.Add( new Person { FirstName “Scott”, LastName “Guthrie”, Age 32 } );
  
people.Add( new Person { FirstName “Bill”, LastName “Gates”, Age 50 } );
  
people.Add( new Person { FirstName “Susanne”, LastName “Guthrie”, Age 32 } );
 

Usando los inicializadores de objetos sólo ahorramos 12 líneas de código extra en este ejemplo en comparación con lo que hubiésemos necesitado con el compilador de C# 2.0.

Los compiladores de Orcas para C# y VB nos permiten mucho más, y ahora soportan los “inicializadores de colecciones” (en inglés: “collection initializers”) que nos permiten evitar tener varias llamadas al método Add, y ahorrarnos aún más tecleo:

   List<Person> people = new List<Person> {
      
new Person { FirstName “Scott”, LastName “Guthrie”, Age 32 },
      
new Person { FirstName “Bill”, LastName “Gates”, Age 50 },
      
new Person { FirstName “Susanne”, LastName “Guthrie”, Age 32 }
   }
;

Cuando el compilador encuentra un código como este último, generará el código necesario para añadir los diferentes elementos a la colección.

Resumen

Como desarrolladores tenemos una nueva forma para hacer nuestro código más conciso a la hora de definir objetos, inicializarlos y añadirlos a colecciones. En ejecución, la semántica será exactamente la misma que la que tenemos con la sintaxis más larga de hoy. (Así que no tenemos que preocuparnos por cambios en el comportamiento). No necesitamos escribir tanto por lo que nuestro código será más corto.

En breve escribiré varios post examinando más de cerca las nuevas características de Orcas, como métodos de extensión (en inglés: Extension Methods), Lambdas, y tipos anónimos. Después me meteré con Linq, y veremos cómo aprovecha todas estas características para facilitarnos una forma elegante para consultar e interactuar con datos.

Espero que os haya gustado.

Scott.

Traducido por: Juan María Laó Ramos. Microsoft Student Partner