LINQ to SQL (2ª Parte – Definiendo nuestras clases del modelo de datos)

En la primera parte de la serie de post sobre LINQ to SQL hablé sobre “¿qué es LINQ to SQL?” y vimos por encima algunos escenarios que permite.

En aquél post pusimos unos cuantos ejemplos de código donde demostrábamos cómo mejorar la parte de datos usando LINQ to SQL:

Links 22 de Mayo: ASP.NET, Visual Studio, Silverlight, WPF y .NET

Una de las cosas que voy a intentar empezar es poner un post semanal con links a sitios de interes sobre temas de .NET que encuentre en la web. Aquí tenéis los links de esta semana Continúa leyendo Links 22 de Mayo: ASP.NET, Visual Studio, Silverlight, WPF y .NET

Usando LINQ to SQL (1ª Parte)

En los últimos meses he escrito una serie de post que cubrían algunas de las característcias que van a venir con Visual Studio y .NET Framework “Orcas”. Aquí tenéis los enlaces:

Las características anteriores hacen que la consulta de datos sea un concepto de primera clase. Conocemos a este modelo de programación como “LINQ” – que viene de .NET Language Integrated Query. Continúa leyendo Usando LINQ to SQL (1ª Parte)

Trucos: Soporte del modo a pantalla completa con Silverlight

Una de las capacidades que tiene Silverlight es el modo a pantalla completa, ocupando completamente toda la pantalla (escondiendo todo de la vista, incluso el frame del navegador). Esto puede ser muy útil a la hora de crear experiencias de usuario, juegos, reproductores de video, etc. Continúa leyendo Trucos: Soporte del modo a pantalla completa con Silverlight

Nueva característica de "Orcas": Tipos anónimos

En éstos últimos dos meses he publicado una serie de post que cubren algunas de las nuevas características que vendrán incorporadas a las release “Orcas” de Visual Studio y del .NET Framework. Aquí tenéis los enlaces a los cuatro primeros:

El post de hoy cubre la última característica en esta serie de post: Tipos anónimos.

¿Que son los tipos anónimos?

Los tipos anónimos es una característica de C# y VB que permiten a los desarrolladores definir tipos “inline” del CLR en el código, sin tener que definir explícita y formalmente una clase para el tipo.

Los tipos anónimos son particularmente útiles cuando consultamos y transformamos/projectamos/formamos datos con LINQ.

Ejemplo de tipo anónimo.

En el post anterior sobre sintáxis de consultas demostramos cómo podeis transformar datos con projecciones. Ésta es una característica muy poderosa de LINQ que nos permite hacer operaciones en una fuente de datos (sin importar si es una base de datos, un archivo XML, o una colección en memoria) e incrustar los resultados de los datos consultados en una estructura/formato diferente que la fuente de datos original.

En el post anterior sobre sintáxis de consultas defínimos una clase propia “MyProduct” que usamos para representar los datos de los productos transformados. Definiendo explícitamente la clase “MyProduct” tenemos un contrato formal de tipos del CLR que podemos usar para pasar los resultados de nuestros productos propios entre servicios web o entre multiples clases/assemblies en nuestra aplicación.

Sin embargo, hay veces cuando sólo queremos consultar y trabajar con datos sin tener que definir una clase explícita para representar esos datos. Aquí es donde los tipos anónimos son muy útiles ya que nos permiten definir tipos concretos dentro de nuestro código.

Por ejemplo, supongamos que usamos el diseñador relacional de LINQ to SQL que viene con “Orcas” para modelar la base de datos “Northwind” con clases de la siguiente forma:

Podemos usar el siguiente código para consultar los datos de Product en nuestra base de datos, y usar la capacidad de proyección/transformación de LINQ para incrustar los resultados en otra cosa que no sea la clase “Product” de arriba. En vez de usar una clase “MyProduct” para representar cada fila de los datos obtenidos de la base de datos, podemos usar los tipos anónimos para definir implícitamente un nuevo tipo con 4 propiedades de la siguiente forma:

En el código de arriba estamos declarando un tipo anónimo como parte de la sentencia “select” dentro de la expresión LINQ, y estamos teniendo la capacidad  del compilador de generar automáticamente el tipo anónimo con cuatro propiedades (Id, Name, UnitPrice y Total Revenue) – cuyos nombres y tipos son heredados por la forma en que construimos la consulta.

Usamos la nueva palabra reservada “var” en C# para referirnos programáticamente a la secuencia IEnumerable<T> de este tipo anónimo que se devuelve en la expresión LINQ, así como para referirnos a cada una de las instancias de ese tipo anónimo dentro de esa secuencia cuando hacemos un bucle foreach más tarde en nuestro código.

Mientras que esta sintáxis nos da la flexibilidad de un lenguaje dinámico, estamos teniendo también los beneficios de un lenguaje fuertemente tipado – incluyendo soporte para tiempo de compilación e intelisense en Visual Studio. Por ejemplo, fijáos en cómo hacemos el foreach anterior sobre la secuencia de productos devueltos y cómo tenemos soporte completo para intelisense y chequeo en tiepmo de compilación del tipo anónimo con propiedades propieas que definimos en la consulta LINQ.

Entendiendo la palabra reservada Var

C# “Orcas” introduce la nueva palabra reservada var que se usará en lugar del nombre del tipo de variable que usaremos.

La mala percepción que la gente suele tener la primera vez que ve esta palabra reservada es pensar que es un paso atrás o una referencia a una variable no tipada (por ejemplo: una referencia a Object ) Esto es incorrecto — la palabra reservada var siempre genera una referencia a una variable de un tipo fuertemente tipada. En lugar de obligar al desarrollador a definir explícitamente el tipo de la variable, la palabra var le dice al compilador que infiera el tipo de la variable de la expresión usada para inicializarla cuando fué declarada por primera vez.

La palabra reservada var puede usarse para referirse a cualquier tipo en C# ( esto es, para referirse tanto a tipos anónimos como a tipos definidos explícitamente). De echo, la manera más facil de entender lo que la palabra reservada var es, es mirar algunos ejemplos de su uson con tipos explícitos. Por ejemplo, podemos usar var de la forma sigiente para definir tres variables:

El compilador inferirá el tipo de las variables “name”, “age” y “male” basándose en el tipo de su asignación inicial (en este caso un string, un entero y un booleano). Esto significa que generará el mismo código IL si las hubiéramos declarado de la siguiente forma:

El CLR no sabrá en realidad que la palabra var está siendo usada – desde su punto de vista no hay diferencia entre los dos códigos anteriores. La primera versión es simplemente una forma que el compilador tiene de ahorrarle al desarrollador unas cuantas pulsaciones de teclas, y es el compilador el que hace el trabajo de inferir y declarar el nombre del tipo.

Además de usar la palabra var para tipos base, podemos usar cualquier tipo que hayamos hecho nosotros. Por ejemplo, podríamos irnos a la consulta de proyección de LINQ que hicimos en el post anterior en el que usábamos un tipo explícito “MyProduct” para la incursaticón y adaptarla para que use la palabra var:

Importante: aunque estemos usando la palabra var en el código de arriba, NO estamos usándola con un tipo anónimo. La consulta LINQ sigue usando la clase “MyProduct” para devolver los datos – lo que implica que “var products” es una colección “IEnumerable<Product> products”. De esta forma la variable “var p” que usamos en el foreach es lo mismo que “MyProduct p”.

Regla importante sobre la palabra var

Debido a que la palabra var  produce un tipo fuertemente tipado en la declaración, el compilador necesita ser capaz de inferir el tipo basándose en su uso. Esto es, tenemos que asignarle un valor inicial al declarala. El compilador nos mostrará un error en caso contrario:

Declarando tipos anónimos

Ahora que hemos introducido la palabra var, podemos empezar a usarala para referirnos a tipos anóniimos.

Los tipos anónimos en C# son definidos usando la misma sintaxis de inicializacón de objetos de la que hablamos en el primer post de esta serie. La diferencia es que en lugar de declarar el nombre del tipo como parte de la inicialización gramatical, cuando instanciamos tipos anónimos dejamos en blanco la parte que viene despues de la palabra new:

El compilador parseará la sintaxis anterior y definirá automáticamente un tipo del CLR con cuatro propiedades. El tipo de cada una de esas cuatro propiedades estan determinadas por el tipo de inicialización que tengan cada una (por ejemplo, en el ejemplo anterior a la propiedad “Id” se le asigna un entero – así que el compilador generará la propiedad el mismo patrón IL que hubiera generado si la hubiesemos declarado explícitamente como entero.

El nombre actual del CLR para el tipo anónimo será generado por el compilador de C#. En realidad el CLR no sabe la diferencia entre un tipo anónimo y tipo no anónimo – así que la semántica de los dos casos son exáctamente iguales. Bart De Smet tiene un gran post donde cuenta los detalles de esto si queréis ver exactamente el patrón del nombre de la clase y el IL generado.

Fijáos arriba cuando escribimos “product.” en el tipo anónimo, seguimos teniendo soporte para el intelisense y chequeo en tiempo de compilación en Visual Studio. También vemos cómo el intellisense nos dice que es un “Anonymous Type” – pero sigue teniendo información completa de las propiedades (el texto rodeado con un círculo rojo).

Uso de tipos anónimos para jerarquías

Uno de los problemas que hacen que los tipos anónimos sean perfectos para usar es la habilidad para construir projecciones jerárquicas de datos con una cantidad mínima de código.

Por ejemplo, podríamos escribir la siguiente expresion LINQ para consultar todos los productos de la base de datos de Northwind cuyos precios sean mayores de 50$ e incrustar los resultados en una estructura jerárquica ordenada por el nivel de stock de Product (usando la sentencia “group into” proporcionada por LINQ)

Cuando el código anterior se ejecuta en ASP.NET, tendremos la siguiente salida en nuestro navegador:

De todas formas podríamos hacer un incrustado jerárquico basandonos en JOIN. Por ejemplo, el código siguiente crea un nuevo tipo anónimo con algunas columnas de productos como propiedades, así como una propiedad con una subcolección jerárquica que contiene los detalles de pedidos de los 5 pedidos más recientes de ese producto en particular:

Fijáos con qué facilidad podemos navegar sobre los datos jerárquicos. Arriba estamos haciendo un bucle sobre la consulta de productos, y luego llenamos la colección con los últimos cinco pedidos de esos productos. Como podemos ver, tengo soporte para el intellisense y chequeo en tiempo de compilación en cualquier parte (incluso en las propiedades de objetos de la subcolecció de los detalles de productos en el tipo anónimo).

Data Binding con tipos anónimos.

Como ya hemos dicho ántes, no hay ninguna diferencia desde el punto de vista del CLr entre tipos anónimos y tipos definidos. Los tipos anónimos y la palabra var son un dulce para evitar que escribamos código – la semántica en el runtime es la misma que si definiéramos los tipos correspondientes.

Entre otras cosas, esto significa que todas las capacidades de reflexión de los tipos estándar de .NET funcionan también con los tipos anónimos – lo que implica que las capacidades de databinding para controles de interfaz de usuario (UI controls) funcionan bien. Por ejemplo, si queremos mostrar lso resultados de la consulta jerárquica anterior de LINQ, podemos definir un <asp:gridview> en un aspx de la siguiente forma:

El .aspx anterior contiene un gridview con 2 columnas estándar con botones y una columna con un template que contiene un control <asp:BulletedList> que suaremos para mostrar la jerarquía de detalles de los pedidos.

Podráimos escribir el código LINQ para construir la consulta jerárquica contra la base de datos y enlacar los datos a nuestro Grid-View:

Como el GridView soporta el enlace con cualquier secuencia IEnumerable<T>, y usa refelxión para obtener las propiedades de los valores, funcionará perfectamente con los tipos anónimos que usamos arriba.

En tiempo de ejecución el código anterior muestra un grid simple de detalles de productos con una lista jerárquica con las cantitades más recientes de los pedidos:

Obviamente podemos hacer este grid mucho más bonito – pero espero que hayáis capatado la idea de lo fácil que es ahora construir consultas jerárquicas sobre bases de datos, incrustarlas los resultados en donde queramos, y trabajar sobre esos resultados en nuestro código o enlazarlos con controles de interfaz de usuario.

Resumen

Los tipos anónimos son una característica que permite a los desarrolladores definir los tipos en el código, sin tener que declarar una clase explícita. Aunque se pueden usar en un monton de escenarios, son particularmente útiles cuando consultamos y transformamos/incrustamos datos con LINQ.

Este post concluye la seríe de 5 post sobre “Orcas”. Haré más post sobre LINQ que demostrarán cómo aprovechar todas estas nuevas características para realizar acceso a datos (definiendo modelos de datos, consultando, actualizando, usando procedimientos almacenados, validaciones, etc). Quería terminar esta serie de cinco post primero, para que tuviéseis una forma fácil de entender todo lo que hay construido debajo del lenguaje a medida que nos vayamos metiendo en algunos escenarios nuevos en próximos post.

Espero que sirva.

Scott

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

SilverLight

El pasado Lunes presente una de las keynotes en las conferencias MIX en Las Vegas, y presentamos un nuevo proyecto en el que he estado trabajando el último año: Silverlight

Silverlight es un plugin .NET multiplataforma (cross platform) y multi navegador (cross browser) que permite a los desarrolladores y diseñadores construir RIA’s para navegadores. La build que se lanzará esta semana soporta Firefox, Safari e Internet Explorer, tanto para Mac como para Windows.

Para haceros una idea de qué clase de aplicaciones podemos hacer con Silverlight, echadle un vistazo a este video de siete minutos de la aplicación de ejemplo “Top Banana”:

Esta aplicación fue hecha con C# y se ejecuta en cualquier sistema que tenga Silverlight isntalado. El tamaño de la descarga total de la aplicación (con todo los archivos XAML y el código compilado) es de 50Kb aproximadamente. Pondremos una versión con el código fuente disponible más tarde este verano.

Mi presentación

Podéis ver mi presentación completa aquí. (Nota: por ahora el video solo muestra las slides y las demos; actualizarán el video a una versión más completa en unas semanas).

Fui muy afortunado al encontrarme con algunos compañeros que me querían enseñar las cosas que habían hecho con Silverlight. Incluían: Netflix (un servicio de videos bajo demanda), CBS (soporte para video generados por el usuario), Metaliq (el video de más arriba) y MLB.com (donde podemos ver la nueva experiencia de usuario del nuevo Major League Baseball).

En la presentación también vismo como podeis usar los nuevos productos de Expression Studio (Design, Blend y el Media Encoder) para hacer videos interactivos. También hice algunas demos de desarrollo – incluyendo unas que mostraban cómo construir un nuevo proyecto SilverLight con Visual Studio, usando el nuevo soporte para Ruby en .NET para que fuese creando la aplicación Silverlight iterativamente con un lenguaje dinámico de consola (que fue hecha completamente con IronPython con Silverlight ejecutandose en Savari en Mac)

Silverlight 1.0

Vamos a tener la primera release de Silverlight este verano. Está centrada en permitir escenarios ricos de contenido multimedia, y ocupará unos 1.2 MB. Algunas de las características que tendrá:

  • Codec intetgrado para reproducir VC-1 y videos WMV, y MP3 y WMA en el navegador. El codec VC-1 en particular es un gran paso para incorporar multimedia a la experiencia web – desde que soporta la reproducción de video de alta calidad de hasta 720p (alta definición). Es el mismo formato soportado en los resproductores HD-DVD y Blueray DVD, y además está soportado por miles de millones de dispositivos móviles, XBOX 360, Windows Media Centers, y Windows Media Players (permitiendo a cualquiera codificar una vez y reproducirlo en todos esos dispositivos + Silverlight).  Esto nos permite usar una libreria inmensa ya existente de contenidos de video y herramientas de edición muy ricas para generar contenidos visuales con Silverlight.
  • Silverlight soporta la abilidad de descargar progresivamente y reproducir contenido multimedia de cualquier servidor web. Podemos indicarle a Silverlight una URL que contenga contenido audio/video,  se lo descargará y nos permitirá reproducirlo en el navegador. No hace falta ningun software serivdor de ningun tipo, Silverlight puede trabajar con cualquier servidor web (Apache en Linux incluido). También estamos trabajando en un conjunto de módulos para IIS que permitan el control óptimo de contenidos multimedia y optimización del ancho de banda para vuestros servidores web.
  • Silverlight también soporta opcionalmente streaming. Esto nos permite usar un servidor de streaming como el Windows Media Server para streaming de video y audio (Nota: Windows Media Server es un producto gratuito que corre en Windows Server). El streaming tiene los siguientes beneficios: 1)Mejoran la expriencia del usuario final cuando buscan sobre un video amplio, y 2) puede disminuir dramáticamente el coste del ancho de banda ( la mayoría de usuarios no ven los videos completos – así que podemos liberar el ancho de banda si dejan de navegar antes de que termine el video con una descarga progresiva).
  • Silverlight permite construir interfaces de usuario ricas y animaciones, y mezclar gráficos vectoriales con HTML. Soporta un modelo de programación para Javascript para esto. Un beneficio de esto es que hace realmente facil integrar estas experiencias con páginas web AJAX (podemos escribir código Javascript para actualizar tanto HTML como elementos XAML).
  • Silverlight hace fácil poder crear ricas experiencias con videos interactivos. Podemos mezclar las capacidades mutlimedia con el soporte de gráficos vectoriales para crear la experiencia multimedia que queramos. Silverlight tiene la habilidad de ponerse en pantalla completa para crear experiencias completamente únicas, así como poder hacer overlay sobre menús, contenidos, controles, textos, directamente encima del contenido de video (lo que nos permite tener experiencias como en los DVD). Silverlight también nos permite ajustar el tamaño de los videos en reproducción al vuelo, sin requerir que el streamin de video se pare o se reinicie.

Podemos desarrollar aplicaciones con Silverlight usando cualquier editor de texto estándar (no hace falta ninguna herramienta). Microsoft ofrecerá soporte para herramientas para Silverlight 1.0 con nuestra suite de productos Expression Studio (incluyendo soporte para herramientas para la administración de encoding de video y audio). Podéis descargar las CTP de Expression Blend y Expression Media Encoder que soportan Silverlight aquí.

Os recomiendo también que veáis estas sesiones del MIX que cubren Silverlight 1.0 y escenarios multimedia (en inglés).

 Silverlight 1.1

En el MIX pusimos la versión beta de Silverlight 1.0 (que tendrá una versión final este verano) y una versión alpha de Silverlight 1.1

Silverlight 1.1 incluye una version multiplataforma del framework de .NET, lo que permitirá una gran experiencia de desarrollo con .NET en los navegadores. El tamaño total de la descarga de Silverlight 1.1 (incluyendo todas las características del 1.0 + CLR + una librería WPF y un subconjunto de la librería FX + soporte para lenguajes dinámicos) será de unos 4MB – y dura poco más de 20 segundos en la instalación.

Algunas de las características que incluye Silverlight 1.1 son:

  • Un motor incrustado del CLR que aporta un rendimiento increíble en la ejecución en el entorno de los navegadores. Silverlight usa el mismo núcleo del motor CLR disponible con la versión completa de .NET. Proporciona el mimo sistema de tipos, recolector de basura, y la generación de código JIT que el vuestros códigos en .NET usan hoy. Esto significa que podemos escribir código .NET que podemos ejecutar con Silverlight, ASP .NET y WinForms/WPF. También significa que podemos ejecutar código en el navegador que se ejecuta 250 veces más rapido que el javascript interpretado.
  • Silverlight incluye un gran framework de librearías que podéis usar para desarrollar apliaciónes basadas en el navegador. Este framework es un subconjunto de todo el framework de .NET que usais hoy en día, y os permite reusar de forma fácil vuestrar habilidades y conocimientos. Incluye soporte para colecciones, genéricos, IO, threading, globalization, networking, y LINQ.
  • Silverlight soporta el modelo de programación de interfaces de WPF. La alpha de Silverlight 1.1 os permite programar buestrar interfaces con código manegado/event handlers, y tiene la habilidad de encapsular controles de interfaz de usuario (construidos con cualquier lenguaje manejado de .NET). La primera version alpha  no trae un conjunto de contorles de interfaz de usuario aún — hemos estado ocupados trabajando en el nucleo de la interfaz de usuario. No os preocupéis, un gran conjunto de controles de alto nivel serán incluidos en el futuro (mientras tanto podéis descargaros algunos controles de ejemplo aquí). WPF para Silverlight será entregado con soporte para el nucleo de constructores de WPF como los layout managers y data-binding (estas características no están implementadas aún en la alpha actual, pero están llegando).
  • Silverlight aporta una api manegada HTML DOM API que os permite programar el HTML de un navegador usando cualquier lenguaje .NET (esto significa que podéis lanzar un evento a un boton HTML usando C# o VB). Silverlight tiene también la habilidad de tener código Javascript en una llamada HTML con métodos .NET que exponéis desde vuestro control/aplicación Silverlight. Silverlight incluye un serializador JSON que  permite una transformación automática desde tipos de .NET hasta/desde Javascript (podeis tener Javascript estándar que llama a un método en C# con Silverlight, y que el método devuelva una colección de .NET que será entonces serializada por Silverlight en una colección Javascript para vuestro navegador).
  • Silverlight no precisa de ASP .NET para sr usado en el servidor web de backend (eso significa que podeis usar Silverlight con PHP e Linux, si queréis). Sin embargo, hemos añadido algunas características que os permitirá integrar fácilmente Silverlight en los clientes y servidores de ASP .NET. Silverlight puede usar los servicios de aplicación estándar de ASP .NET (membership, roles, profile, etc), y pueden llamar tanto a servicios web WCF o ASMX. Esta semana también publicamos nuevos controles de servidor ASP.NET que hacen realmente fácil hostear controles Silverlight en páginas ASP.NET.
  • Abajo tenéis un video de 22 minutos que muestra cómo construir una aplicación Silverlight desde cero usando Visual Studio y Expression Blend (haced clic aquí para descargaros los controles que uso.

<

Podéis hacer clic en la siguiente imagen para descargaros un poster que os muestra una visión global de los namespaces de .NET y las características que ofrece la alpha de Silverlight 1.1.

También me hicieron una entrevista en Channel 9 que podéis ver para aprender un poco más sobre cómo el modelo de programación manejado trabaja con Silverlight, y cómo le añadimos el soporte para el CLR

Acualización del 10 de mayo: También hice un podcast con Scott Hanselman que podeis descargaros y escuchar aquí.

También os recomiendo que veais estas sesiones del MIX sobre los diferentes escenarios sobre Silverlight 1.1 y .NET.

  • Building Silverlight Applications using .NET (Part 1)
  • Building Silverlight Applications using .NET (Part 2) 
  • Extending the Browser Programming Model with Silverlight
  • Podéis descargaros el código fuente de las partes 1 y 2 en el sitio de Nick aquí.

    Soporte de lenguajes dinámicos.

    En el MIX anunciamos la primera releasede una nueva librería .NET a la que llamamos “Dynamic Language Runtime” (a partir de ahora DLR).

    Hemos investigado durante mucho tiempo haciendo que .NET y el CLR sean un entorno de primera clase para lenguajes dinámicos, y hace poco más de un año formamos un group dedicado dentro de mi equipo y ha estado centrado en construir un mejor soporte para lenguajes dinámicos en el CLR.

    El nuevo Dynamic Language Runtime (DLR) añade un pequeño conjunto de sevicios específicamente diseñados para el CLR para escenarios con lenguajes dinámicos. Entre otras cosas hay un sistema de tipos dinámicos compartidos, modelo de hosting de lenguajes y soporte para hacer más facil la generación rápida de código dinámico. Con estas nuevas características es muchísimo más facil implementar lenguajes dinámicos para .NET.

    La importancia de las implementaciones de lenguajes dinámicos que usan el soporte DLR es que no son interpretados. En lugar de eso, hemos usado las características de generación de código ligero (lightweight-code-generation) que se añadieron en el CLR 2.0 para crear código IL en memoria que será compilado con JIT en código nativo en tiempo de ejecución (sin tener que guardar nunca nada en disco). De esta forma se puede obtener mucho más rendimiento que un código interpretado, y también nos aseguramos de que cuando se termina la compilación JIT podemos opcionalmente usar el recolector de basura para eliminar la latencia. Pudiendo de esta forma coneguir un entorno muy potente para la programación con lenguajes dinámicos, y permitiendo a los desarrolladores programar contra las API’s de .NET con lenguajes dinámicos.

    El DLR – y todos los lenguajes construidos sobre él – se puede usar en aplicaciones multiplataforma con Silverlight en navegadores, aplicaciones en servidor ASP .NET, y con WPF/WinForms en entornos de escritorio (basicamente en cualquier lugar donde se pueda ejecutar el CLR).

    En el MIX hemos anunciado que Microsoft aportará cuatro implementaciones de lenguajes dinámicos para .NET.

    • Python
    • Ruby (new)
    • Javascript
    • Dynamic VB (new)

    Publicaremos el código fuente de las implementaciones de Python y Ruby, así como el código de la librería DLr en CodePlex (todos los códigos serán publicados con todos los derechos para la publicación). Podéis descargaros el tanto el DLR como la implementación de Python (conocida como IronPython) hoy mismo en el sitio de IronPython de CodePlex. El código de la implementación de Ruby (que vamos a llamar IronRuby) también será publicado en CodePlex en unas semanas.

    Para aprender más sobre nuestro soporte para lenguajes dinámicos, os recomiendo que veáis este video de John Lam mostrando una consola de lenguajes dinámicos creada con IronPython corriendo en Silverlight en un Mac. Permite a los desarrolladores crear interactivamente aplicaciones Silverlight (con soporte para intellisense y todo) en el navegador usando Ruby, Python, Javascript y VB:

    También os recomiendo que veáis esta sesion del MIX sobre Silverlight 1.1 con lenguajes dinámicos.

    www.Silverlight.net

    La semana pasada lancamos nuestro último sitio: http://www.silverlight.net

    Como con www.asp.net y www.iis.net, usaremos este sitio para publicar ejemplos y videos de “How-to”. También tiene una parte de foros para que nos hagáis preguntas sobre Silverlight.

    Haz clic aquí para suscribirte al RSS de los nuevos contenidos que iremos publicando en las semanas y meses venideros.

    Resumen.

    Silverlight abre un montón de nuevos horizontes donde crear increibles experiencias de usuario multiplataforma y multinavegador.

    Para los desarrolladores de .NET, significa poder escribir código .NET usando cualquier lenguaje de desarrllo (VB, C#, Javascript, Python, Ruby y más) en el navegador (usando Silverlight), servidores web (usando ASP.NET), en aplicaciones de escritorio, y para dispositivos móviles. Seréis capaces de usar Visual Studio y la suite de Expression Studio para llegar a todos esos escenarios.

    Debo decir, que me apasiona el futuro que ofrece Silverlight. Aún tenemos trabajo que hacer, errores que corregir, añadir controles de usuario – pero el núcleo de gráficos/media/runtime que hemos publicado es extremadamente potente y proporciona una base muy sólida y escalable con la que serguir trabajando.

    Escribiré aún más sobre Silverlight, y cómo usarlo, en las próximas semanas y meses.

    Espero que sirva.

    Scott.

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

    Test unitarios y NUnit

    Las máquinas no hacen lo que quieren, hacen lo que nosotros les decimos que hagan.

    No sé muy bien dónde lo escuché, ni quien me lo dijo, o si lo vi en algún articulo o en una ppt. Pero es una verdad como un templo. Cuando escribimos código, tanto para un hola mundo como para un sistema de control de un aeropuerto, lo que esperamos de nuestros aporreos de teclado es lo que hagan lo que estábamos pensando mientras escribíamos.

    Hay una gran diferencia entre lo que un programador piensa que debe hacer su código y lo que realmente hace el código recién escrito. Y ya no digamos del código que escribimos hace unas semanas.

    Hace relativamente mucho tiempo que aparecieron los primeros frameworks para realizar test unitarios, y se van mejorando cada día. Pero, ¿qué son los test unitarios?, para los que no lo sepáis aún, según Ron Jeffries:  “ son programas escritos para ejecutarse uno tras otro. Normalmente comprueban que ante unas entradas predefinidas, los resultados obtenidos van a ser siempre los mismos.”

    Es decir, son programas que van a comprobar que nuestro código haga lo que esperamos que haga.

    NUnit.

    NUnit es un framework más para poder realizar de forma homogénea y estructurada los menesteres que he descrito en el apartado anterior.

    Por intentar demostrar que me he mirado esto un poco a fondo, aunque no mucho, os cuento que NUnit es la implementación para la plataforma .NET de otro framework para hacer test unitarios, JUnit. JUnit es un framework para realizar test unitarios para la plataforma Java, que a su vez viene de la plataforma … (y aquí me cansé de investigar).

    Todo el tema de los test unitarios ha surgido con las técnicas de desarrollo rápido Extreme Programming. Éstas últimas son técnicas de programación usadas para explotar varios factores del desarrollo software, como son la calidad, claridad, tiempo de desarrollo, eficiencia, y un largo etcétera.

    Al grano.
    Hablando en plata (“talking in silver”) , básicamente lo que necesitamos para poder hacer test unitarios con NUnit es:  Primero descargárnoslo desde www.nunit.com, y lo segundo es instalarlo.

    Una vez lo tengamos instalado ya podemos ponernos a hacer test a mansalva.
    La forma en que los hago yo es la siguiente: Me creo un nuevo proyecto de librería C# en visual studio, le añado la referencia a la dll de NUnit. (En la documentación de NUnit os dice dónde la podéis encontrar).

    Y listo, ya puedo crear las clases que testearan lo que yo quiera.

    Sólo hay que tener en cuenta un par de cosas:

    1. Añadir el atributo TestFixture  a las clases que van a contener los test, por ejempo:

    using System;
    using NUnit.Framework;
    namespace UnitTestingExample
    {
        [TestFixture]
        public class SomeTests
        {
        }
    }

    1. Tenemos que indicar los métodos que van a hacer los test mediante el atributo Test

     [TestFixture]
      public class SomeTests
      {
        [Test]
        public void UnTest()
        {
               //Hacer algo
        }
      }

    Y listo, ya podemos testear lo que queramos.

    NUnit nos ofrece un interfaz gráfico para ver los resultados de los test. ¿Cómo lo vemos? Muy fácil, compilamos nuestra librería, ejecutamos el interfaz gráfica que NUnit tiene preparado, en el menú File, seleccionamos Open, y podemos seleccionar la dll compilada que hemos generado con visual studio.

    Muchas veces es necesario inicializar algunas cosas para que los test puedan ejecutarse. Por ejemplo, que haya un elemento en la base de datos, que se haya inicializado el valor de algunas variables, etc..

    Para ello, están los atributos [TestFixtureSetUp] y  [TestFixtureTearDown]. El primero inicializa todo lo que haya que inicializar ANTES de ejecutar los test, y la última se ejecutará DESPUÉS de ejecutar todos los test, de esta forma:

    [TestFixtureSetUp]
    public void MetodoDeSetup()
    {
      //Código necesario para la inicialización
    }

    [TestFixtureTearDown]
    public void MetodoDeTearDown()
    {
      //Codigo
    }

    Pues nada, espero que os sirva tanto como me ha servido a mi.

    Pero NUnit no se queda sólo en esto, tiene muchas cosas más que dejaremos para otros post.

    Hope this help.

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

    Instalando Visual Studio Team Foundation Server

    Alguien dijo alguna vez que las instrucciones no sirven para nada. Yo diría que no sirven mucho, pero algo sí.

    He tenido que instalar Visual Studio Team Foundation Server, y me ha costado un poquito. Al principio no leí las instrucciones, me daba unos cuantos avisos diciendo:

    • El SQL Server Agent no está iniciado, y no está configurado para ejecutarse manualmente.

    • La actualización KBXXXX (No me acuerdo del número) no está instalada.

    Y así un largo etcétera.

    Despues de ir solventando los diferentes problemas que iban surgiendo. Ya pude iniciar la instalación. Pero “Oh campos mustios de soledad verdes tullidos”, al poco de iniciar la instalación me decía que los servicios Windows Sharepoint Services están configurados para trabajar con WMSDE, y debería estar configurado para trabajar con SQL Server.

    Pues bien, aquí, después de leer y releer las instrucciones que iba encontrando, desinstalando los Windows Sharepoint Services, varias veces. No me indicaba dónde poder decirle que usase el SQL Server como motor de base de datos.

    Investigando un poco por las cosas que tenía instaladas en el sistema, me dió por señalar la pestaña de “Mostrar las actualizaciones instaladas”

    Y bualá, aparecía un componente llamado Windows Microsoft Sql Server Desktop Engine …

    Las iniciales me hicieron sospechar: WMSDE, ¿será esto?

    Total, que lo desinstalé, y cuando volví a instalar Windows Sharepoint Services porfín me dejaba seleccionar qué origen de datos usar.

    Espero que le sirva a alguien.

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