• Habilidad para agregar una nueva fila al control DataGrid
• Mejoras el tiempo de carga de las aplicaciones
• Soporte para la rueda del mouse en las aplicaciones fuera del navegador para Mac
• Se arreglaron unos bugs relacionador con el uso de DRM para contenido multimedia
• Se arregló una fuga de memoria relacionada con el uso de MouseCapture
• Se arregló una fuga de memoria relacionada con el uso de DataTemplate

Aquí los pasos para bajar la nueva versión:

Para usuarios finales

Lo recomendado en el post de Tim Heuer es modificar el tag de object que hospeda nuestro xap dentro de nuestra página:

<object data="data:application/x-silverlight-2," type="application/x-silverlight-2"
  width="640" height="400">
    <param name="source" value="YOUR_PATH_TO_XAP" />
    <param name="background" value="white" />
    <param name="minRuntimeVersion" value="4.0.50826.0" />
    <param name="autoUpgrade" value="true" />
      <a href="http://go.microsoft.com/fwlink/?LinkID=149156&amp;v=4.0.50826.0" style="text-decoration: none">
        <img src="http://go.microsoft.com/fwlink/?LinkId=161376" alt="Get Microsoft Silverlight"
          style="border-style: none" />
       </a>
</object>

La clave aquí están en las líneas 5 y 6, minRuntimeVersion indica que la versión mínima requerida para correr la aplicación y autoupgrade le pedirá permiso al usuario para actualizar la aplicación si la versión de Silverlight instalada es menor a la requerida.

Para desarrolladores

Debes actualizar tanto el developer runtime como el SDK (preferentemente en ese orden). Aquí las ligas para realizarlo:

• Windows developer runtime
• Mac developer runtime
• Silverlight 4.0.50826.0 SDK

Una vez instalados el runtime y el SDK puedes crear un nuevo proyecto de Silverlight y el tag de object reflejará automáticamente la nueva versión:

Puedes leer más información en el post de Tim Heuer y en el Knowledge Base de la actualización (KB2164913).

Cabe mencionar que su disponibilidad es inmediata, es decir, justamente después de terminar la sesión pueden seguir estos pasos y descargar el video.

Paso 1: Entren al mismo vínculo que usaron para registrarse a la Sesión en cuestión

La lista de vínculos está en esta dirección

Paso 2: Regístrense (no estoy seguro si se los vuelve a pedir si ya lo hicieron con anterioridad, por favor que alguien nos ayude a confirmar esto)

Paso 3: Indica un nombre para la Sesión de Live Meeting (requerido).  Una vez hecho eso hagan clic en el botón “Confirmar”

Paso 4: En la pantalla que dice “Gracias por registrarse” hagan clic en el botón “Descargar”

Paso 5: Capturen su correo y nombre de Empresa (sí, otra vez )

Paso 6: Descarguen el video usando el icono de “Microsoft Office Live Meeting Replay”

Paso 7: Se descargará un archivo .zip.  Guárdenlo y abránlo ya que contiene el video en formato .wmv.

Espero que esto aclare todas sus dudas al respecto.

Salu2!!!

En el último episodio #585 se menciona a La Liga Silverlight, como la primera Comunidad MSDN en Español acerca de Silverlight y tecnologías relacionadas.  Además, Arturo Molina los invita a Guadalajara… chequen lo que contestaron

Los invito a que escuchen este episodio y que .NET Rocks! esté en su lista de podcasts favoritos!

Antes que otra cosa, quiero agradecer a todos y todas quienes me ayudaron a contestar la encuesta que preparé en días pasados.  Recibí más de 250 respuestas de personas de diversos países: Argentina, Bolivia, Chile, Colombia, Costa Rica, Ecuador, El Salvador, España, Estados Unidos, Guatemala, México, Nicaragua, Perú y Venezuela.

Tomando en cuenta todas las respuestas, tengo el gusto en anunciarles el Taller de Silverlight 4: un curso constituído por 8 partes, de 1 hora cada una.  Se llevará a cabo en línea, por las noches.

Taller de Silverlight 4

Descripción

Este curso gratuito de 8 sesiones te ayudará a comprender los fundamentos de la plataforma de desarrollo de Silverlight y te servirá para tener los conocimientos necesarios para construir aplicativos Web de tipo RIA que hagan uso, validación y manipulación de datos.  La gran mayoría de estos conceptos los podrás aprovechar también para el desarrollo de soluciones de Windows Phone 7!

Temario general

Partes 1 y 2: Fundamentos de Silverlight

Partes 3 y 4: Aplicaciones Fuera del Navegador

Partes 5 y 6: Enlace y Validación de Datos

Partes 7 y 8: Consumiendo Datos

Para toda la información más actualizada acerca del taller visiten esta página.

Finalmente…

No me queda mas que invitarlos a todos(as) a que asistan, estoy seguro de que aprenderán bastante de esta fabulosa tecnología!

Salu2!!!

Si tienes 3 minutos, puedes contestar la encuesta en su sitio para hacerle saber qué es lo que mejor funciona para ti.

¡Gracias! y por favor corran la voz.

Modificando el Servicio de Dominio (DomainService)

En la parte 2, de esta serie de post, agregamos nuestra Clase de Servicio de Dominio, la cual llamamos RiaDomainService.cs. Esta clase, como ya lo explicábamos, es la encargada de exponer las diferentes acciones que podemos ejecutar desde y hacia nuestros datos.

El primer paso que haremos es agregar un nuevo método que nos permita filtrar los datos. Al hacerlo de esta manera, el filtrado de datos lo estaremos haciendo en la capa media, que bien podríamos ver como la capa de negocio (business).

Básicamente nuestro método será muy parecido al método que ya tenemos para obtener la lista de productos, pero este nuevo método recibirá un parámetro el cual usaremos para el filtrado de datos. En esta ocasión lo que haremos es filtrar los datos por los registros que comiencen con el texto que el usuario decida sobre la columna de nombre de producto.

El método lo llamaremos GetProductsStartingWith, y recibirá un texto como parámetro el cual llamaremos startingName. Y los datos serán filtrados utilizando el método Where() que nuestro modelo de datos no entrega, en el cual utilizaremos expresiones lambda.

public IQueryable<Product> GetProductsStartingWith(string startingName)
{
    return this.ObjectContext.Products.Where(p => p.Name.StartsWith(startingName));
}

Vista y Ventana de Fuente de Datos (Data Sources Window)

Al igual que cuando agregamos la lista de productos, el Data Source Window nos permite agregar los controles que en esta ocasión serán necesarios para mostrar la lista filtrada; el DataGrid, un cuadro de texto, y un botón, es una sola acción.

Para lograr esto, en el Data Source Window necesitamos indicar que para la lista de productos, el query a utilizar será GetProductsByNameQuery.

* Si el query no está disponible, es probable que necesitemos recompilar nuestra solución una vez que agregamos el nuevo método a nuestro DomainService, o presionar el icono de recargar disponible en la ventana de Data Source.

Una vez que hemos seleccionado el query solo bastará arrastrar el elemento a nuestro xaml.

Ejecutando la aplicación

Nuevamente, nuestra aplicación ya está terminada con apenas estos pequeños pasos que hemos hecho.

Aquí la explicación de lo que ha sucedido en nuestro archivo xaml.

Los elementos agregados: un DomainDataSource, un DataGrid, un Label, un TextBox, y un Button.

El primer elemento que necesitamos analizar es el DomainDataSource. Éste tiene los valores de acuerdo a:

• Es generado con un nombre (Name=”productDomainDataSource”),
• utiliza la función de GetProducts (QueryName="GetProductsByNameQuery"),
• que no serán cargado automáticamente (AutoLoad="False")
• y al ser cargados los datos, ejecutará el método productDomainDataSource_LoadedData (LoadedData="productDomainDataSource_LoadedData")

Adicionalmente, al DomainDataSource se le ha agregado un elemento llamado QueryParameters, el cual nos permite enviarle los parámetros pertinentes al query que estamos ejecutando, que en esta ocasión será:

• el parámetro startingName (ParameterName="startingName")
• cual será leído desde el textbox startingNameTextBox, que también ha sido agregado y analizaremos más adelante (Value="{Binding ElementName=startingNameTextBox, Path=Text}").

<riaControls:DomainDataSource AutoLoad="False"
                              d:DesignData="{d:DesignInstance my1:Product, CreateList=true}"
                              Height="0"
                              LoadedData="productDomainDataSource_LoadedData"
                              Name="productDomainDataSource"
                              QueryName="GetProductsStartingWithQuery"
                              Width="0">
    <riaControls:DomainDataSource.DomainContext>
        <my:RiaDomainContext />
    </riaControls:DomainDataSource.DomainContext>
    <riaControls:DomainDataSource.QueryParameters>
        <riaControls:Parameter ParameterName="startingName"
                               Value="{Binding ElementName=startingNameTextBox, Path=Text}" />
    </riaControls:DomainDataSource.QueryParameters>
</riaControls:DomainDataSource>

Además, como lo podemos observar, se han agregado un Label, un Textbox, un Button y un DataGrid, los cuales son muy intuitivos en su función. Básicamente el texto que el usuario escriba en el TextBox servirá como filtro de los datos a mostrar en el DataGrid, una vez presionado el Button. Y esto es ejecutado ya que se ha agregado un enlace (Binding) al Domain Data Source (Command="{Binding Path=LoadCommand, ElementName=productDomainDataSource}")

<StackPanel Height="30"
            Orientation="Horizontal">
    <sdk:Label Content="Starting Name:"
               Margin="3"
               VerticalAlignment="Center" />
    <TextBox Name="startingNameTextBox"
             Width="60" />
    <Button Command="{Binding Path=LoadCommand, ElementName=productDomainDataSource}"
            Content="Load"
            Margin="3"
            Name="productDomainDataSourceLoadButton" />
</StackPanel>

Otra forma de hacer filtros…

En el siguiente post, veremos cómo hacer filtrados de datos desde nuestro DomainDataSource, esto sin necesidad de modificar nuestros Servicios de Dominio…

Saludos…

Introducción

Una de las características mas deseadas para SilverLight es la posibilidad de crear reportes de negocios con Reporting Services, en este articulo, mostraré como utilizar la actual tecnología de Reporting Services junto con Silverlight y RIA Services para lograr ese cometido.

Lo primero que haremos es crear una aplicación Silverlight, en este caso use la plantilla Silverlight Business Application.

En el proyecto web, agrego un Modelo Entity Framework.

Para esta demostración, estoy utilizando la base de datos AdventureWorksLT.

Estas son las entidades que usare para esta demostración:

Generamos el proyecto y añadimos una clase Domain Service:

Aca tenemos todas las entidades a ser añadidas al Domain Service:

Ahora podemos agregar un nuevo Reporte. En este caso, utilizaremos Reporting Services en modo local.

Cuando diseñamos el reporte, al agregar un componente del tipo Tablix, se nos pide agregar a su vez un Dataset. En este caso, el asistente de escogencia del dataset ve el domain context que añadimos anteriormente.

Para esta demostración cree una clase que utilizare para enlazar el reporte. Hay casos es que es conveniente hacer esto ya que pudiéramos necesitar tener que hacer un procesamiento de datos extra antes de enlazarlo con el reporte:

using System;
using System.Collections.Generic;

using System.Linq;
using System.Web;

using System.ComponentModel.DataAnnotations;

namespace ReportingServicesDemo.Web
{
    public class Orders
    {
        public Orders()
        { }

        [Key]
        public int OrderDetailsID
        {
            get;
            set;
        }

        public int OrderID
        {
            get;
            set;
        }

        public string Product
        {
            get;
            set;
        }

        public int Quantity
        {
            get;
            set;
        }

        public decimal UnitPrice
        {
            get;
            set;
        }

        public decimal UnitPriceDiscount
        {
            get;
            set;
        }

        public decimal LineTotal
        {
            get;
            set;
        }
    }
}

En esta clase hacemos referencia al espacio de nombres System.ComponentModel.DataAnnotations que me permite agregar un atributo Key a la propiedad  OrderDetailsID  , este es un requerimiento para la clase para que el domain service lo reconozca como una entidad valida.

Si vemos el codigo del domain service, encontramos lo siguiente:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Data;
using System.Linq;
using System.ServiceModel.DomainServices.EntityFramework;
using System.ServiceModel.DomainServices.Hosting;
using System.ServiceModel.DomainServices.Server;

//// Implements application logic using the AdventureWorksLT2008Entities context.
//// TODO: Add your application logic to these methods or in additional methods.
//// TODO: Wire up authentication (Windows/ASP.NET Forms)
///        and uncomment the following to disable anonymous access
//// Also consider adding roles to restrict access as appropriate.
// [RequiresAuthentication]
[EnableClientAccess()]
public class ADWLTDomainService :
       LinqToEntitiesDomainService<AdventureWorksLT2008Entities;
{

Ahora creo una operación del domain service que exponga la entidad Orders que acabo de crear en mi clase personalizada.

public IQueryable <Orders> GetOrderDetails(int OrderID)
{
    AdventureWorksLT2008Entities adw = new AdventureWorksLT2008Entities();

    var query = from c in adw.SalesOrderDetail.Include("Product")
                where
                c.SalesOrderID == OrderID
                select new Orders { OrderID = OrderID,
                OrderDetailsID = c.SalesOrderDetailID, Product = c.Product.Name,
                Quantity = c.OrderQty, UnitPrice =
                c.UnitPrice, UnitPriceDiscount = c.UnitPriceDiscount,
                LineTotal = c.LineTotal };
   return query;
}

En este metodo utilizo el contexto del Entity Framework en vez del contexto del domain service, y lo expongo igual que los demás métodos de selección como IQueryable.

Al generar nuevamente el proyecto, el asistente de escogencia del dataset ve el nuevo metodo que acabamos de crear con todos los campos de la entidad listos para nuestro reporte.

Aca vemos el diseño del reporte con el dataset disponible:

Ahora añadimos un WebForm en el proyecto web y le agregamos un control ReportViewer para visualizar el reporte:

Cuando agregamos el control ReportViewer , se crea en forma automática un control ObjectDataSource:

Cuando vemos las propiedades del ObjectDataSource, podemos ver en la propiedad Selectmethod nuestro método personalizado:

Inspeccionando la colección  SelectParameters, podemos ver el parámetro del método antes creado.

Ahora en el proyecto Silverlight, agregamos un DataGrid enlazado a la entidad Sales Orders.

Para esta demostración, cada campo de Sales Orders ID es representado con un botón, la idea es pasar el contenido del mismo a través del evento Click del botón:

HtmlPopupWindowOptions options = new HtmlPopupWindowOptions();
options.Left = 0;
options.Top = 0;
options.Width = 930;
options.Height = 800;
options.Menubar = false;
options.Toolbar = false;
options.Directories = false;
options.Status = false;

Button btn = sender as Button;

int OrderID =int.Parse(btn.Content.ToString());

string address = Application.Current.Host.Source.AbsoluteUri;
int i = address.IndexOf("/ClientBin/", 1);
string url = address.Substring(0, i);
url = url + "/RpDemoWebForm.aspx?OrderID=" + OrderID;

if (true == HtmlPage.IsPopupWindowAllowed)
    HtmlPage.PopupWindow(new Uri(url), "new", options);

Podemos obtener la dirección URL donde la aplicación xap de silverlight corre, mediante la propiedad  Application.Current.Host.Source.AbsoluteUri. Luego podemos crear la URL asociada con el WebForm donde esta el control ReportViewer.

Finalmente podemos ver nuestro reporte de detalles de la orden:

Espero que les sirva de utilidad para cuando necesiten integrar sus reportes con Silverlight.

Bueno pues sin mas, hay que descargar estas herramientas para poder seguir desarrollando aplicaciones de SilverLight en nuestro Visual Studio 2010 en español, las cuales pueden descargar desde aquí

Por cierto, por alguna razón no me carga el diseño de una aplicación de SilverLight 4 que había hecho con Visual Studio 2010 en ingles, aunque al ejecutarla en el explorador si me muestra lo que contenía dicha aplicación… es extraño!

Ahora a seguir haciendo pruebas!

Saludos

Aplicación Silverlight

Como ya lo hemos comentado, la aplicación silverlight que el template ‘Silverlight Business Application’ no entrega ya cuenta con el ‘Framework de Navegación’. En esta ocasión estaremos trabajando únicamente en nuestra página ‘Home.xaml’.

VS2010 y la Ventana de Fuente de Datos (Data Sources window)

Una de las ventajas que trae consigo el Visual Studio 2010, es que ahora podemos ligar los servicios de datos expuestos por WCF RIA Services en nuestra applicación Silverlight de manera visual; así pues, desde la ventana de ‘Data Sources’ podemos arrastrar un ‘DataGrid’ (que a continuación analizaremos).

La ventana de Data Sources, es lo suficientemente inteligente como para leer los servicios WCF que nuestra aplicación Web expone, y nos entrega los diferentes objetos expuestos.

Ejecutando la aplicación

y listo, ahora sí ya tenemos nuestra primera aplicación RIA Services lista para ser ejecutada. Sin embargo considero importante entendamos que es lo que está pasando tras bambalinas…

Origen de Datos de Dominio (Domain Data Source)

La primera parte del código entregado consiste del control llamado DomainDataSource el cual viene incluido en los assemblies que RIA Services nos entrega.

Este control será el encargado de contener los datos que la aplicación Web expone a través de la Clase de Servicio de Dominio.

• Es generado con un nombre (Name=”productDomainDataSource”),
• utiliza la función de GetProducts (QueryName=”GetProductsQuery”),
• que serán cargado automáticamente (AutoLoad=”True”)
• y al ser cargados los datos, ejecutará el método productDomainDataSource_LoadedData (LoadedData=”productDomainDataSource_LoadedData”)

También es configurado para que el Origen de Datos sea el Contexto de Dominio desde la aplicación Web.

DLL: System.Windows.Controls.DomainServices
Namespace: xmlns:riaControls=”clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.DomainServices”
Namespace: xmlns:my=”clr-namespace:WCFRiaServices01.Web.Services”
Namespace: xmlns:my1=”clr-namespace:WCFRiaServices01.Web.Models”

<riaControls:DomainDataSource AutoLoad="True"
                              d:DesignData="{d:DesignInstance my1:Product, CreateList=true}"
                              Height="0"
                              LoadedData="productDomainDataSource_LoadedData"
                              Name="productDomainDataSource"
                              QueryName="GetProductsQuery"
                              Width="0">
    <riaControls:DomainDataSource.DomainContext>
        <my:RiaDomainContext />
    </riaControls:DomainDataSource.DomainContext>
</riaControls:DomainDataSource>

Mostrando los datos en un DataGrid

Una vez que tenemos los datos en nuestro DomainDataSource, estos son mostrados en un control DataGrid.

Nuestro DataGrid tendrá

• un nombre (Name=”productDataGrid”);
• las columnas no serán autogeneradas (AutoGenerateColumns=”False”);
• y lo más importante, el origen de datos estará enlazado con nuestro Domian Data Source (ItemsSource=”{Binding ElementName=productDomainDataSource, Path=Data}”)

DLL: System.Windows.Controls

Namespace: xmlns:sdk=http://schemas.microsoft.com/winfx/2006/xaml/presentation/sdk

<sdk:DataGrid AutoGenerateColumns="False"
              Height="200"
              ItemsSource="{Binding ElementName=productDomainDataSource, Path=Data}"
              Name="productDataGrid"
              RowDetailsVisibilityMode="VisibleWhenSelected"
              Width="400">
    <sdk:DataGrid.Columns>
        ...
    </sdk:DataGrid.Columns>
</sdk:DataGrid>

Y las columnas haran referencia al dato con la propiedad de Binding apuntanto a la columna correspondiente (Binding=”{Binding Path=Class}”)

<sdk:DataGridTextColumn x:Name="classColumn"
                        Binding="{Binding Path=Class}"
                        Header="Class"
                        Width="SizeToHeader" />

Las columnas generadas, detectarán el tipo de dato desde la BD, y harán la conversion respectiva, así pues para la fechas se utilizará el formato adecuado. (Esto lo veremos en un post posterior).

Siguientes post…

Aunque ya tenemos una aplicación que corre sobre RIA Services, apenas estamos calentando motores, en los siguientes post estaremos hablando de cómo hacer paginación de los datos mostrados, cómo crear filtros, cómo mostrar los detalles de un registro, etc, etc, etc…

*Puedes ver el post original aqui

Plantilla de VS2010 para WCF Ria Sercvices

Lo primero que necesitamos mencionar es que el framework de Ria Services nos ofrece una plantilla (template) para VS2010 llamada ‘Silverlight Business Appication’ que nos entregará una solución totalmente configurada para comenzar a trabajar. Esta solución viene ya incluso con las siguientes características:

• La solución está compuesta por dos proyectos, una aplicación web y una aplicación Silverlight. La aplicación web será la encargada de la conexión y acceso a la base datos, así como la que proyectará los datos hacia la aplicación silverlight, que será la que le de vista a estos.
• La aplicación Silverlight que nos entrega está creada sobre el framework de navegación (para leer sobre el Framework de Navegación puedes ir a estos post)
• Servicios de manejo de usuarios (membership) ya están incluido. (estos los veremos cómo usar y modificar en un post posterior)

Modelo de Datos

Para poder acceder a los datos desde nuestra aplicación Silverlight, es necesario crear "en nuestra aplicación web" un modelo de datos y proyectarlos desde nuestra aplicación web con una clase de servicio de dominio.

Lo primero que haremos es crear un modelo de nuestra base datos. Esto será, como ya lo hemos mencionado, del lado de nuestra aplicación web. En esta ocasión agregaremos un nuevo elemento del tipo ‘ADO.NET Entity Data Model’. Le pondremos por nombre ‘RIAModel.edmx’. (Como sugerencia, la pondremos en la carpeta ‘Models’)

Esto nos lanzará un asistente. En el primer paso nos permitirá seleccionar el contenido de nuestro modelo, en esta ocasión seleccionaremos que sea generado desde una base de datos.

En el siguiente paso del asistente configuraremos los datos de conexión de la base de datos.

*Yo usaré la base de datos de AdventureWorks sample databases que pueden encontrar en el web para su descarga.

En el tercer paso del asistente, seleccionaremos los objetos que queremos estén incluidos en modelo de datos. Además configuraremos el Namespace del Modelo.

*Para nuestros propósitos por ahora solo seleccionaremos la tabla de Product (Production), y nombraremos el Namespace del Modelo como: RiaModel

Al seleccionar la opción de pluralizar o singularizar lo nombre de los objectos generados (Pluraliza or singularize generated object names), le estamos diciendo al modelo que los objetos deberan tener el nombre de entidad en plural y el nombre en singular, lo cual nos ayudará a entender posteriormente de una mejor manera con que tipo de objeto estamos trabajando al hacer consultas a los datos.

Al terminar el asistente tendremos un esquema del modelo de datos como este. Observemos que el ‘Entity Set Name’ esta pluralizado.

Una vez completado nuestro modelo, tendremos que compilar el proyecto, ya que para la siguiente sección, es necesario tener nuestro modelo de datos ya disponible.

Clase de Servicio de Dominio

El siguiente paso en el que trabajaremos será el encargado de proyectar los datos desde nuestra aplicación web hacia nuestra aplicación silverlight. Y esto lo lograremos agregando un elemento del tipo ‘Domain Services Class’, el cual añadiremos a nuestro proyecto web en la carpeta llamada ‘Services’, lo cual haremos en la carpeta de Services y lo llamaremos RiaDomainService.cs

Al agregar este tipo de clases, nos lanzará un asistente que nos permitirá seleccionar los elementos configurados en nuestro Modelo de Datos que queremos sean proyectados por medio de un servicio, así como una opción para permitir sean editados. Además de que también nos ofrece la opción de crear las clases asociadas para los metadatos de los objetos (dedicaremos un post a este tema).

*Si no se muestra ninguno de los elementos configurados anteriormente es probable que el proyecto no fuera compilado previamente.

Los elementos que nos entregará serán un par de clases, en mi caso: RiaDomainService.cs y RiaDomainService.metadata.cs. Como lo comenté, la segunda de ellas la abordaremos con mayor detalle en un post posterior. Pero de la que si necesitamos hablar es de la de RiaDomainService.cs.

Lo que podemos platicar hasta este momento de esta clase es que:

1. Como podemos ver, está etiquetada con [EnableClientAccess()], ya que pedimos fuera editable.
2. Nos crea 4 funciones básicas: GetProducts(), InsertProducts(), UpdateProducts() y DeleteProducts(). El típico ABC de una base de datos.
3. Esta clase es 100% modificable para nuestros propósitos. Así pues por ejemplo, si quisiéramos que nuestro método GetProducts() nos regrese los registros de manera ordenada, solo bastaría modificarla de tal modo que quedaría:

public IQueryable<Product> GetProducts()
{
    return this.ObjectContext.Products.OrderBy(p => p.Name);
}

Continuará…

Ya hemos configurado nuestra aplicación web para proyectar los datos, en nuestro siguiente post ahora sí comenzaremos a consumir estos datos y a mostrarlos desde nuestra aplicación silverlight…

Saludos

*Puedes ver el post original aqui

Si bien, ya habia comenzado una Serie de post sobre WCF Ria Services, me he decidido a comenzar nuevamente con el tema por las siguientes razones:

• El lanzamiento oficial de la versión RTM de Visual Studio 2010
• El lanzamiento oficial de Silverlight 4
• El lanzamiento oficial WCF Ria Services v1.0
• Ademas de que durante este tiempo he estado trabajando muy de lleno en un sitio (razón por la cual dejé de lado la continuación de la serie antes mencionada), en donde mi experiencia ha sido enfocada a la tecnología de WCF Ria Services, por lo que los conocimiento adquiridos me han hecho ver el tema con diferentes ojos.

Y como podrán darse cuenta, creo conveniente recomenzar con el proyecto de aportar con mi granito de arena sobre el tema. Sin embargo, como lo que fuimos es lo que nos hacer ser lo que somos, tomaré mucha de la información y forma de lo que en la antigua serie trate de hacer.

Que es WCF Ria Services?

Ria Services es un framework que provee una serie de funcionalidades (dlls, templates, etc) que permiten acceder datos en una Aplicación Silverlight desde una Base de Datos. Esto es gracias a su implementación en modelo de capas (n-tier application), donde Ria Services trabaja en las capas intermedias ofreciendo control de acceso, cambios y operaciones definidas por el usuario, así como funciones de de validaciones, autentificación de usuarios y roles en las capas superiores.

Referencia: http://silverlight.net/riaservices/

Página WCF Ria Services, instaladores y recursos de aprendizaje

La principal página de WCF Ria Services la podemos encontrar en http://www.silverlight.net/riaservices. En donde podemos encontrar los instaladores. Así como una serie de recursos de aprendizaje (videos, documentos, blogs, etc).

Recursos para trabajar en Ria Services

Hacer notar WCF Ria Services ya está incluido en el instalador de las herramientas de Silverlight 4 para Visual Studio 2010 (Silverlight 4 Tools for Visual Studio 2010). Sin embargo en la página podemos encontrar el instalador standalone para la versión v1.0 de WCF Ria Services, así como el instalador para el paquete de herramientas de WCF Ria Services (WCF RIA Services Toolkit).

También podemos encontrar las siguientes páginas sobre el tema

• WCF RIA Services Code Gallery
• Documentación de MSDN sobre WCF RIA Services

Continuará…

Igual, si bien en este primero post no nos hemos adentrado (codificado) en la tecnología. No podemos dejar de lado la información contenida en este.

Para nuestro siguiente post si estaremos trabajando ya con código.

Saludos

*Puedes ver el post original aqui

Windows Phone 7 es la próxima versión del sistema operativo para dispositivos móviles de Microsoft.  Debido a que su liberación está muy próxima las herramientas de desarrollo para Visual Studio .NET 2010 han sido liberadas en su fase Beta.  Esta es una excelente oportunidad para que puedan meterse en esta plataforma, que cabe mencionar, usa Silverlight como tecnología para sus aplicaciones!

Así es, si ustedes son desarrolladores de Silverlight ya saben cómo construir aplicativos para Windows Phone 7.  Las instalación de las herramientas incluye una versión de Blend 4 para WP7, las plantillas para VS.NET y el Emulador de WP7.  Pueden descargar las herramientas aquí.

Además de las herramientas, se ha actualizado el Training Kit de Windows Phone 7 a esta última versión Beta.  El Training Kit cuenta con una serie de Prácticas y Documentación para que aprendan rápidamente los conceptos para desarrollar soluciones en el télefono.  Lo pueden descargar aquí.

Es bastante emocionante ser hoy en día un desarrollador de Silverlight, y mucho más aún sabiendo que tus conocimientos los puedes aplicar en esta plataforma móvil.  ¿Deseas iniciar en Silverlight y no sabes cómo?  Revisa el Curso de Introducción a Silverlight 4 – totalmente en Español!

Salu2!!!

Al contrario de lo que se pensaba, sí tendremos Professional Developers Conference (PDC) este año!  El evento se realizará por primera vez en el Campus de Microsoft en la ciudad de Redmond, WA. los días 28 al 29 de Octubre 2010.

Si nunca han atendido les recomiendo ampliamente que lo consideren ya que este es el evento por excelencia en donde se dan a conocer las tecnologías que próximamente serán lanzadas; además el contenido es totalmente técnico.  Además, es buen pretexto para conocer el nido de Microsoft 

Por otro lado, si no pueden asistir les recuerdo que el evento se transmitirá en vivo y muy probablemente los videos estén disponibles posteriormente para descarga.

Salu2!

Como lo dice Tim Heuer en su post, con esto Rodrigo es reconocido oficialmente como uno de los principales exponentes de la tecnología en toda América Latina.

Todos hemos aprendido algo de él, y hoy me permito abrir este espacio para felicitarlo, y para agradecerle el gran esfuerzo que le pone a la transmisión de conocimiento de SL.

Rodrigo, felicidades por este nuevo reconocimiento…

Con el lanzamiento de Visual Studio 2010 en español, existe un problema cuando se hace la instalación sobre cualquier otra versión de Visual Studio 2010 en otro idioma (en mi caso en inglés).

No es posible crear una aplicación de SilverLight 4 ya que, al  momento de escribir este texto, aun no se ha lanzado el paquete de SilverLight 4 tools for Visual Studio 2010 en español, por lo que tendremos que esperar a los chicos de Microsoft para poder crear aplicaciones de SilverLight 4 en nuestro Visual Studio 2010 en español.

Si alguien mas ha tenido este problema, o ha encontrado alguna solución al respecto, favor de comentarlo.

Saludos

• Compatibilidad con Visual Studio .NET 2010
• Soporte para Windows Phone 7
• PathListBox
• Nuevos Efectos Visuales (Pixel Shaders)
• Nuevos Comportamientos
• Soporte para el patrón de diseño MVVM
• Mejoras en SketchFlow, como la opción de publicar directamente a una lista en SharePoint y poder ver el feedback de varias personas al mismo tiempo!
• Etc…

Si son subscriptores, la descarga ya está disponible en MSDN.  Además les recuerdo que la actualización de Expression Studio 3 a Expression Studio 4 es totalmente gratuita.  Lo único que tienen que hacer es instalar la versión Trial de Expression Studio 4 *sobre* su versión licenciada de la v3.

Para mayor información de todas las novedades en el resto de productos de la familia Expression visiten su sitio oficial.

Salu2!

Poco después ya estaba yo usando el nuevo juguete para crear aplicaciones en mi lugar de trabajo. De igual manera, no tomó mucho tiempo para percatarme que los ejemplos que había visto en la feria estaban cuidadosamente planeados y daban una impresión incorrecta. Tan pronto como uno quería crear algo más complejo que un par de botones y campos de entrada, el código subyacente comenzaba a crecer y hacerse difícil de controlar.

Tras una pausa de varios años en la que estuve envuelto exclusivamente en el ámbito de Linux, volví a Windows esta vez usando Visual Studio y C#. Sin embargo, encontré que la práctica de usar  las ventanas (Windows Forms) como los módulos de la aplicación todavía seguía en vigencia. Aún ahora, no es raro encontrar clientes con aplicaciones que tienen ventanas con 3000 o más líneas de código subyacente.

¿Es eso malo? Aunque personalmente no me gusta tal estilo de programción, no creo que sea malo o bueno. Mientras funcione, ¿qué importa? Por supuesto, la manutención del proyecto puede ser un reto. Especialmente si los desarrolladores originales ya no están disponibles. Aunque no hay clausulas goto en el código, definitivamente es una bola de espagueti.

“Yo diseño el programa mientras lo escribo”

Será por lo fácil que es sentarse simplemente a escribir código que muchos tendemos a ni siquiera tener una idea nebulosa de lo que queremos conseguir cuando ya estamos creando una interfase gráfica y escribiendo código subyacente. Como dice Steve McConnell, es como si al querer construir una casa, comenzáramos a erigir el edificio sin ningún plan determinado, simplemente poniendo juntos los materiales y dejando que la forma de la casa, con todos sus detalles vaya surgiendo poco a poco. La analogía muestra el poco sentido de tal estrategia. Para construir un edificio hay que tener al menos un plan general de la distribución de los cuartos o habitaciones de la casa. Algunas decisiones tienen serias repercusiones en el resultado. ¿Será una casa con una o dos plantas? La estructura básica es diferente en cada caso.

A veces he oído a algunos decir que es más bien como una pintura o escultura, donde el artista deja que su medio le vaya sugiriendo le dirección a seguir. Pero aún así, un artista tiene una noción de lo que intenta producir. Antes de poner óleo en la lona o clavar el cincel en el mármol, el artista tiene un boceto en papel o en su mente. Si el producto deseado es un retrato o un busto, y termina con una pintura o escultura de un caballo, algo anda mal. Por más que el artista diga que es lo que su inspiración le dictó (o lo que el mármol le pidió), el cliente no va a estar satisfecho con ser percibido en términos equinos.

Bocetos en software

Volviendo a mi enamoramiento inicial con Delphi (y C++ Builder), por ese tiempo también salió un libro que eventualmente se convirtió en un clásico: Design Patterns: Elements of Reusable Object-Oriented Software. Si bien no es revolucionario, sí es especial por definir en forma concreta estrategias específicas para implementar algunos tipos de soluciones a problemas que aparecen repetidamente en la creación de aplicaciones. Desafortunadamente, el tono no es exactamente como el de un libro de Stephen King, lo que dificulta un poco su lectura. Por dicha, a través de los años han surgido otros volúmenes con un enfoque más asequible a los que somos simples mortales.

En fin, los patrones de diseño no son exactamente procedimientos o recetas para la creación de software, sino más bien bocetos a grandes rasgos de la forma general que puede tomar una solución a un problema específico. Nótese el gran número de términos imprecisos en la oración anterior. Es a propósito.

Es más, un patrón en general no tiene la intención de dictar cómo se debe diseñar el programa, sino que más bien, la idea es que, a medida que uno va diseñándolo, encontrará situaciones donde la solución comienza a asemejarse al patrón. Tal como hay ciertas guías para reorganizar código (refactorings), los patrones sirven como guías para reorganizar el diseño o arquitectura del sistema. Y tal como una lectura del tomo por Fowler nos deja la impresión de explica algo que es obvio, las descripciones sobre patrones de diseño tienden a sonar simplonas y autoevidentes.

Orden en el escritorio

Volviendo al tema de las aplicaciones que crecen forma orgánica. Yo pienso que la clave es ser equilibrado. El arquitecto, o el artista comienza con una idea general, probablemente nebulosa. A medida que dibuja el boceto, algunos conceptos comienzan a tomar formas definidas. Puede que los primeros intentos resulten defectivos, pero no importa, al cabo se trata de ideas generales. Luego viene el diseño detallado donde hay que tomar innumerables decisiones sobre la forma definitiva de lo que se está creando.

En software, no tiene sentido tratar de diseñar la aplicación completa sin escribir ni una sola línea de código. Pero tampoco es sensible empezar a escribir código sin siquiera tener una idea general de cual es la forma general y propósito del sistema. Entendiendo esos conceptos iniciales de lo que se quiere resolver con la aplicación es lo que permite decidir qué herramientas usar. Por ejemplo, no toda aplicación es candidata a ser desarrollada en Silverlight, o con ASP.NET, o hasta con Windows.

De igual manera, si resulta que Silverlight es la solución apropiada, no toda aplicación es apta a ser diseñada de la misma manera. Independientemente de su aspecto gráfico, las necesidades de un juego son comúnmente muy diferentes de las de un procesador del matrículas para una universidad.

Siendo aún un poco más atrevido, diré que la forma en que se diseña la aplicación tiene poca importancia si al final el producto trabaja apropiadamente. Pero hay ciertas condiciones. Por ejemplo, de seguro cada uno de nosotros tiene formas diferentes de organizar el escritorio. Para algunos, el escritorio debe estar limpio, y tener solamente lo que se está usando en ese momento. Papeles, libros y demás están todos organizados en archivadores y estantes. Para otros, el escritorio consta de torres de papeles y libros, junto con docenas de otros objetos apilados sin ton ni son aparente. En ambos casos, mientras la persona se sienta cómoda y sea productiva, el estado del escritorio es irrelevante.

Por supuesto, puede que algunos objeten sobre el desorden del segundo caso. Se ve feo. Es un completo desorden. No obstante, en muchos casos los habitantes de tales alborotos saben muy bien dónde está todo y lo pueden encontrar en un instante. Es más, todo está a la mano. Se puede argumentar que la persona con el escritorio ordenado tiene un mejor ambiente de trabajo. Es cierto, la apariencia es nítida y todo está en su lugar, pero cualquier cosa que tal persona necesite, requiere un viaje al archivador o al librero. De modo que las ventajas no son tan evidentes. Cada estilo tiene puntos buenos y malos. Mientras la persona esté cómoda en su propio escritorio, tales comparaciones son fútiles.

El lío se arma cuando viene alguien no familiarizado con el sistema. Un nuevo trabajador tendrá serios problemas encontrando algo en el escritorio similar a la zona de guerra. Hasta que no sea tan experto como el trabajador original, su productividad va a ser terrible. Por otra parte, un trabajador nuevo al que le toque el escritorio ordenado y clasificado tendrá menos dificultades en ser productivo. Eventualmente puede que en ambos escritorios los trabajadores sean igual de productivos, pero el tiempo que toma llegar a ese nivel es muy diferente en cada caso.

Es cuestión de equilibrio

Pasando la analogía al diseño de software, una aplicación en la que toda la lógica ocurre en el código subyacente de las ventanas o formularios de web, no es necesariamente mala. La funcionalidad está toda allí y no hay que navegar una docena de clases antes de encontrar quién diantres escribe los datos al archivo.  De igual manera, una aplicación organizada minuciosamente en componentes o capas no es necesariamente mejor. Cada capa o separación introduce más complejidad y afecta el rendimiento del sistema.

Sin embargo, si existe la posibilidad de que múltiples desarrolladores trabajen simultáneamente (o en diferentes épocas) en el sistema, hay ciertas ventajas en un sistema más organizado y separado en componentes con responsabilidades definidas. El tiempo que toma entender el sistema a grandes rasgos es menor. En fin,  la mantención del sistema es más simple.

De nuevo, el asunto es ser equilibrado. ¿Se trata de una aplicación personal? ¿O tal vez una aplicación utilitaria con un par de botones y dos o tres controles adicionales? En tales casos el trabajo de organizar la aplicación puede tener pocas ventajas.

Pero si hablamos de aplicaciones empresariales, o cuando existe la posibilidad de que otros tengan que mantener el sistema más adelante, o de que se tenga que alterar el sistema a medida que los requerimientos cambian, es buena idea considerar seriamente una organización más estricta para la aplicación.

Nótese que tal organización sería muy diferente de un caso a otro. Puede que la organización implique mejores comentarios, o el uso de regiones, o la creación de algunas clases auxiliares. O puede que implique subsistemas múltiples divididos a su vez en componentes y clases.

Silverlight y MVVM

Al final, llegamos al meollo del asunto. Al inicio teníamos aplicaciones en Windows. Luego surgió ASP y ASP.NET, ambos con diferentes modelos y entornos de trabajo que requieren una filosofía diferente al escribir aplicaciones. Todos los que han cruzado al mundo de aplicaciones de Web están familiarizados con el impacto que causa darse cuenta de que cada vez que el navegador envía una acción al servidor, éste ha olvidado completamente todo lo que habíamos creado hace apenas un segundo, y tiene que comenzar de nuevo desde cero.

De igual manera, Silverlight es lo suficientemente diferente de Windows Forms y ASP.NET como para requerir un reajuste en nuestra forma de crear aplicaciones. Los que han desarrollado en ambos entornos, tienen cierta ventaja, pero es todavía un reto. Más fácil es para los que han desarrollado en WPF, puesto que Silverlight es muy similar.

Desde un principio, los desarrolladores en WPF notaron que el patrón MVVM se adapta muy bien a ciertos tipos de aplicaciones en este entorno. Tal característica ha sido heredada por Silverlight. Es más, en Silverlight la separación entre el cliente y le servidor es intrínseca y concreta, en vez de ser simplemente un artefacto conceptual. La naturaleza física de la separación hace fácil el ver los datos como algo remoto, hasta cierto punto ajeno a la aplicación Silverlight en el cliente que tiene cierto sabor a presentador de tal información.

El problema perenne en tal situación es el pegamento o adaptador entre el mundo de los datos y el mundo visual de su representación. MVVM es un boceto, o estrategia para implementar tal intermediario. El propósito es crear sistemas en los que hay cierto número de componentes con responsabilidades claramente definidas.

¿Quiere decir que toda aplicación en Silverlight debería ser diseñada usando el patrón MVVM? NO. MVVM no es la única estrategia disponible. De hecho, es posible crear una aplicación al estilo tradicional, usando solamente código subyacente. Una vez más, depende del tipo de aplicación, su uso, y las circunstancias en las que se va a mantener.

Con todo y todo, MVVM ha tomado cierto impulso dentro de la comunidad de desarrolladores de Silverlight, y sea que uno esté de acuerdo o no, es bueno al menos saber de qué se trata.

Bueno entonces, ¿qué p(bip) es MVVM?

Aunque parezca mentira, nadie sabe con absoluta certeza la respuesta a esa pregunta. El problema es que MVVM es extremadamente ambiguo en su definición. Las siglas representan el nombre en inglés para Modelo, Vista y Modelo de Vista. Y la definición básica es que el modelo contiene los datos, la vista presenta esos datos al usuario, y el modelo de vista es lo que conecta a ambos.

Es fácil ver los problemas de tal concepto. De hecho, ¿exactamente qué significa que el modelo contenga los datos? ¿Qué hay de las reglas o lógica que manipula tales datos? ¿Está el modelo a cargo de la seguridad de la información mediante autenticar y autorizar su acceso? Y la vista, ¿tan sólo presenta los datos, o también se encarga de responder a acciones del usuario? ¿Puede la vista hacer pequeños cambios a la información, o tiene que enviar cada solicitud de cambio al modelo?

Y en todo esto, ¿qué es el modelo de vista, y por qué es necesario? ¿Por qué no puede la vista simplemente conectarse al modelo sin usar un intermediario? Y si al final se nos convence de que se ocupa el modelo de vista, ¿exactamente qué es lo que hace? ¿Cómo puedo adaptarlo a mi diseño?

Esas y otras muchas preguntas son comunes y las respuestas aún están tomando forma. Nadie tiene todavía una idea completa del asunto. De hecho puesto que es tan sólo un patrón de diseño, la forma específica que tome su implementación cambiará de aplicación a aplicación.

Por experiencia propia, yo sugiero:

• Investigar y obtener un concepto general del tema
• Estudiar tantos ejemplos como sea posible
• Tratar de diseñar una aplicación relativamente pequeña  usando el patrón

Para el primer ítem, he publicado un artículo escrito originalmente en inglés por Jeremy Likness explicando en detalle el MVVM y presentando algunos casos comunes donde uno puede encontrar dificultades. También ofrece comentarios sobre varias bibliotecas que ayudan a implementarlo. Hace algún tiempo empecé a escribir un artículo con una idea similar, pero Jeremy hizo un trabajo mucho mejor.

Habiendo estudiado el patrón, fastidiado a varios miembros de la comunidad con montones de preguntas, y caminado paso a paso por docenas  de ejemplos, hace poco tuve la oportunidad de ejecutar el tercer paso y crear una aplicación pequeña pero lo suficientemente compleja como para justificar el uso del patrón (ok, ok, tal vez no tan justificadamente). El proceso fue interesante y lleno de lecciones. Mi plan es dar cuenta de algunos los puntos principales en futuros artículos que puedan servir de ayuda a los que van por el mismo camino.

Si están en la ciudad les invito a que asistan, la entrada es libre!!!

Los datos son:

Fecha: Sábado 22 de Mayo 2010

Lugar: Pullman Hotel

Hora: 09:00 horas

¡Allá nos vemos!