ramaygon – Página 4 – ILUMINA TU CÓDIGO

Acceso a listas de SharePoint 2010 a través de Silverlight

La unión hace la fuerza, basándome en esta celebre frase, vamos a unir la capacidad de respuesta y la interactividad de SharePoint 2010, con el amplio abanico de posibilidades que ofrece Silverlight en cuanto a la creación de experiencias de usuario se refiere.

Para demostrar la productividad de esta unión, vamos a crear un Webpart de basado en Silverlight.Este leerá el contenido de las diferentes listas, que contiene el sitio de SharePoint 2010 que usaremos para este artículo.

Comenzaremos accediendo a el sitio de SharePoint 2010 sobre el que vamos a trabajar a lo largo de este artículo. Dentro del mismo vamos a crear una biblioteca de documentos, en la que guardaremos el archivo .XAP. Resultante de implementar la solución desarrollada en Silverlight.

La creación de la biblioteca de documentos la realizaremos accediendo a Acciones de Sitio->Nueva Biblioteca de Documentos, como podemos observar en la siguiente imagen:

Al realizar dicha acción, nos surgirá una ventana emergente en la que introduciremos el nombre de la biblioteca de documentos.En este caso la nombraremos como StoreSilverlight el resto de opciones las dejaremos como en la siguiente imagen:

Ahora vamos a añadir una nueva WebPart con formato Silverlight. Nos situamos en Acciones del Sitio y elegimos la acción de Editar Página.

Al elegir está acción, nuestra página pasará a estado de edición. En la sección Herramientas de edición elegimos la pestana Insertar. Seguidamente seleccionamos la opción Elemento Web(Webpart).

Ahora en la sección Categorías seleccionamos Medios y Contenidos y por último elegimos Elemento Web de Silverlight y elegimos Aceptar.

Realizando la anterior acción, nos aparecerá una ventana emergente donde se pedirá la url donde vamos a situar el archivo .XAP. Elegiremos la url de la biblioteca de documentos StoreSilverlight, creada con anterioridad. En la parte final de este artículo, indicaremos al webpart el lugar y nombre exacto del archivo .XAP.

Como podéis observar se a creado el WebPart pero no tiene contenido, así que manos a la obra para crear ese contenido. Creamos un nuevo proyecto en Visual Studio 2010, la plantilla que vamos a utilizar es Visual C#->SharePoint->2010->Empty SharePoint Project. El nombre del proyecto será ImplementarSolSP.

Al crear este proyecto, se pide que apunte hacia el sitio web con el que estamos trabajando:

El siguiente paso es incluir un nuevo proyecto Silverlight, para ello nos situamos en la solución(ImplementarSolSP) con el botón derecho y elegimos Añadir nuevo proyecto. Elegimos la siguiente plantilla Visual C#->Silverlight->Silverlight Application. El nombre de el proyecto será AplicacionSilverlight. Al crear el proyecto debemos deseleccionar, la opción de crear un alojamiento de prueba para el proyecto creado como podemos observar en la siguiente imagen:

El último paso que realizaremos en nuestro proyecto Silverlight es cambiar el fondo de nuestro proyecto, para que este se distinga cuando sea implementado en el WebPart.

Accedemos al archivo MainPage.Xaml y dentro de la etiqueta Grid incluiremos el siguiente fragmento de código:

    <Grid.Background>
        <LinearGradientBrush EndPoint=»0.5,1″ StartPoint=»0.5,0″>
            <GradientStop Color=»Black» Offset=»0″ />
            <GradientStop Color=»White» Offset=»1″ />
        </LinearGradientBrush>
    </Grid.Background>
</Grid>

Ahora añadimos a ImplementarSolSP el módulo que consigue incluir el archivo .Xap de Silverlight en SharePoint 2010. Presionamos con el botón derecho sobre la solución ImplementarSolSP, elegimos añadir nuevo elemento y elegimos la plantilla Visual C#->SharePoint->2010->Module. El nombre del módulo será ModuloSilverlight.

Seguidamente en el explorador de soluciones de Visual Studio 2010, vamos a situarnos con el botón derecho sobre el archivo Sample.txt y elegiremos la opción borrar.

Ahora vamos a decir a nuestro proyecto SharePoint que implemente la solución a través de el modulo de Silverlight que hemos creado con anterioridad. Para ello, hacemos Click sobre ModuloSilverlight y en la sección propiedades de Visual Studio 2010, seleccionamos el botón desplegable de la propiedad Project Output References como podemos observar en la siguiente imagen:

Al presionar dicho botón aparecerá una ventana emergente en la que presionaremos sobre añadir.Al añadir un nuevo miembro debemos de elegir el tipo de implementación como ElementFile y el nombre del proyecto será AplicacionSilverlight como podemos observar en la siguiente imagen:

Presionamos Ok para realizar la correspondiente acción.

Ahora nos situamos en el archivo Elements.xml, dejando su contenido del siguiente modo:

<?xml version=«1.0« encoding=«utf-8«?>
<Elements xmlns=«http://schemas.microsoft.com/sharepoint/«>
  <Module Name=«ModuloSilverlight« Url=«StoreSilverlight«>
    <File Path=«ModuloSilverlightAplicacionSilverlight.xap« Url=«AplicacionSilverlight.xap« Type=«GhostableInLibrary«/>
  </Module>
</Elements>

Como podemos observar le decimos al módulo de carga que guarde el archivo .Xap en nuestra biblioteca de documentos StoreSilverlight.

Ahora solo queda construir la solución (F6 en Visual Studio 2010), después implementaremos la solución:

Finalmente comprobaremos que la solución a través del archivo AplicacionSilverlight.xap a sido añadida a la biblioteca de documentos StoreSilverlight.

Para que se cargue AplicacionSilverlight.xap en el Webpart deberemos situarnos en el WebPart y elegir la opción abre el panel de herramientas, al realizar dicha acción se desplegará el cuadro de opciones del WebPart como podemos observar a continuación:

Al presionar configurar nos pedirá una url donde está situado el archivo que va ser mostrado en la WebPart:

De esta forma podremos ver que efectivamente la solución de Silverlight se ha implementado en el WebPart:

Vamos a pasar a la segunda parte del artículo que es poder acceder a las listas de nuestro sitio SharePoint 2010 y trabajar con su contenido a través del WebPart de Silverlight creado con anterioridad.

Abrimos la solución ImplementarSolSP con Visual Studio 2010 y accedemos al proyecto AplicacionSilverlight. Presionando sobre referencias con el botón derecho, elegimos añadir nueva referencia.En la ventana emergente elegiremos la pestaña examinar, las librerías que queremos usar son Microsoft.SharePoint.Client.Silverlight y Microsoft.SharePoint.Client.Silverlight.Runtime, que están situadas en C:Archivos de ProgramaCommon FilesMicrosoft SharedWeb Server Extensions14TEMPLATELAYOUTSClientBin .

Ahora debemos de referenciar dichas librerías en el proyecto. Abrimos AplicacionSilverlight.xaml.cs y las referenciamos añadiendo el siguiente código:

using Microsoft.SharePoint.Client;

Abriremos el archivo App.xaml.cs y referenciamos nuevamente las librerías añadiendo el siguiente código:

using System.Windows.Shapes;
using Microsoft.SharePoint.Client;

Nos situamos en el método Application_Startup incluyendo el siguiente código en el mismo:

private void Application_Startup(object sender, StartupEventArgs e)
{
    ApplicationContext.Init(e.InitParams, SynchronizationContext.Current);
    this.RootVisual = new MainPage();
}

De esta forma sincronizaremos SharePoint con el proyecto Silverlight.

Ahora vamos a modificar la interfaz del proyecto Silverlight. Abrimos AplicacionSilverlight.xaml e incluimos el siguiente código:

<Grid x:Name=»LayoutRoot»>
        <Grid.Background>
            <LinearGradientBrush EndPoint=»0.5,1″ StartPoint=»0.5,0″>
                <GradientStop Color=»Black» Offset=»0″ />
                <GradientStop Color=»White» Offset=»1″ />
            </LinearGradientBrush>
        </Grid.Background>
        <StackPanel Orientation=»Horizontal» >
            <ListBox Name=»lbLists» Width=»300″ Height=»400″ ScrollViewer.VerticalScrollBarVisibility=»Auto» Margin=»20,20,20,20″  />
            <TextBox Name=»txtDetails» Width=»200″ Height=»400″ TextWrapping=»Wrap» />
        </StackPanel>
    </Grid>

Como podemos observar hemos introducido dentro de Grid principal un objeto ListBox que cargará las diferentes listas de SharePoint y un objeto TextBox que se encargará de cargar los detalles de cada una de las listas.

Ahora situándonos en AplicacionSilverlight.xaml.cs vamos a incluir dos variables, _sitio se encarga de cargar el sitio y _list se encarga de cargar las diferentes listas del sitio.

private Microsoft.SharePoint.Client.Web _sitio;
private Microsoft.SharePoint.Client.List _list;

El siguiente paso es la creación del contexto basado en el sitio que utilizamos para este artículo y cargarle las listas de este sitio. Para ello debemos introducir el siguiente código en el constructor:

public MainPage()
{
    InitializeComponent();
    ClientContext context = new ClientContext(ApplicationContext.Current.Url);
    // creamos un nuevo contexto sobre el sitio que vamos a trabajar
 
    _sitio = context.Web;//cargamos el contexto en la variable
    //cuando carga el contexto cargará las listas y el sitio
    context.Load(_sitio);
    context.Load(_sitio.Lists);
    //la llamada del contexto ha de hacerse de forma asincrona
    context.ExecuteQueryAsync(new ClientRequestSucceededEventHandler(OnRequestSucceeded), new ClientRequestFailedEventHandler(OnRequestFailed));
}

A continuación vamos a agregar los dos métodos que hemos nombrado en la llamada asincrona utilizada con anterioridad:

private void OnRequestSucceeded(Object sender, ClientRequestSucceededEventArgs args)
{ //si la petición se a realizada correctamente se llama al método FillList 
    Dispatcher.BeginInvoke(FillList);
}
 
private void OnRequestFailed(Object sender, ClientRequestFailedEventArgs args)
{
}
private void FillList()
{
    //borra el listbox con los contenidos que tenia anteriormente
    lbLists.Items.Clear();
    lbLists.ItemsSource = _sitio.Lists;
    //se carga en el listBox las diferentes listas
    lbLists.DisplayMemberPath = «Title»;
    //se muestra el campo de la lista que se va mostrar
}

Situándonos en el área de diseño de AplicacionSilverlight.xaml, haremos doble clic sobre el ListBox, para generar el evento de cambio de selección de Item. Al realizar dicha acción accederemos directamente a AplicacionSilverlight.xaml.cs e incluiremos el siguiente código:

private void lbLists_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    using (ClientContext context = new ClientContext(ApplicationContext.Current.Url))
    {
        _list = context.Web.Lists.GetByTitle(((Microsoft.SharePoint.Client.List)lbLists.SelectedItem).Title);
        context.Load(_list);
        context.ExecuteQueryAsync(new ClientRequestSucceededEventHandler(OnListDetailsRequestSucceeded), null);
    }
}
private void OnListDetailsRequestSucceeded(Object sender, ClientRequestSucceededEventArgs args)
{ //Añadimos la  rutina de devolución de llamada para la consulta asincrónica:
    Dispatcher.BeginInvoke(ShowListDetails);
}

Por último añado el método que mostrará los detalles de la lista seleccionada en el ListBox en el TextBox:

        private void ShowListDetails()
{
    string infoAboutList =
        string.Format(«List Details:» + Environment.NewLine + «Title: {0}» + «Description: {1}» + «Item Count: {2}» + «Base Template: {3}» + «Base Type: {4}» + «Content Types Enabled?: {5}» + «Hidden?: {6}»,
        _list.Title + Environment.NewLine,
        _list.Description + Environment.NewLine,
        _list.ItemCount + Environment.NewLine,
        _list.BaseTemplate + Environment.NewLine,
        _list.BaseType + Environment.NewLine,
        _list.ContentTypesEnabled + Environment.NewLine,
        _list.Hidden + Environment.NewLine);
 
    txtDetails.Text = infoAboutList;
}

Para ver el efecto de todos los cambios que hemos realizado, construimos nuevamente la solución(F6 en Visual Studio 2010) e implementamos la solución. El paso definitivo es refrescar la página en la que hemos introducido la WebPart de Silverlight. El resultado es el de la siguiente imagen:

En conclusión, uniendo las dos plataformas de Microsoft podemos crear unas experiencias de usuario muy dinámicas, donde tenemos un nivel de productividad muy alto. Ahora solo queda que le deis una vuelta de tuerca a la idea inicial y conseguiréis proyectos realmente profesionales.

Material MSBREAK 2010

Después de realizar la charla del MSBREAK 2010 solo me queda agradecer la asistencia a toda las personas que me escuchasteis y el personal que colaboró conmigo en la charla. Deciros que podéis descargaros la presentación aquí. Las diferentes demos utilizadas en el evento las podréis obtener aquí. Espero veros pronto en próximas charlas, un saludo!!

Cambios API de Impresión en Silverlight 4 RC

Con la puesta en marcha de la versión RC de la plataforma Silverlight 4, se han producido una serie de cambios en ciertas novedades de la versión Beta de Silverlight 4 ya presentaba. Voy a reseñar los cambios que presenta la API de impresión.

En la versión Beta cuando deseabas introducir el nombre del documento se realizaba del siguiente modo:

PrintDocument docToPrint = new PrintDocument();
docToPrint.DocumentName = "Nombre del documento";

En la versión RC es obligatorio introducir el nombre del documento y forma parte del método Print() como podemos observar:

PrintDocument docToPrint = new PrintDocument();
docToPrint.Print( "Demostración API de Impresión");

Otro de los cambios es que ha desaparecido el método StartPrint() por el método BeginPrint como podemos observar en los siguientes fragmentos de código:

En la versión Beta

docToPrint.StartPrint += (s, args) =>
              {
                  ActivityDisplay.IsActive = true;
              };

En la versión RC

docToPrint.BeginPrint += (s, args) =>
    {
        ActivityDisplay.IsActive = true;
        
    };

En conclusión, si hemos realizado proyectos con la versión Beta de Silverlight 4, podemos encontrarnos que en las versión RC fallen los citados elemento.De este modo introduciendo los nuevos métodos, podemos disfrutar plenamente de la funcionalidad de impresión de la plataforma.

MICROSOFT BREAK 2010

El próximo 19 de abril de 2010 en la Universidad Pública de Navarra se celebrará el evento Microsoft Break en el que gracias a la invitación de Microsoft impartiré una charla sobre Silverlight. Dicho evento contará de dos charlas, la primera tratará sobre Windows Azure será impartida por Elisa (integrante del equipo de desarrollo de Microsoft) se tratarán temas como la definición de la nube y los distintos tipos de servicios que se pueden ofrecer.
En adición, se presentará Windows Azure, un sistema operativo de servicios en la nube que trabaja como entorno de desarrollo, hospedando servicios y controlándolos, con soporte a todo tipo de lenguajes y entornos, además de los propios de Microsoft.

En cuanto a la charla de Silverlight se tratará las aplicaciones ricas en Internet consistentes en el aprovechamiento de la experiencia de usuario en herramientas y funciones de escritorios naturales. La integración del diseñador en el ciclo de desarrollo del Software, las distintas novedades que se han incluido en la versión 4 de la citada plataforma y por último como sacar un rendimiento productivo a las aplicaciones de Silverlight desarrolladas en entornos móviles.

Os animo a que asistáis a este evento registrándose aquí.

Elaborar un Lector de RSS en Silverlight 4

Hoy voy a proponer un proyecto que en si tiene gran utilidad, un lector de Rss en Silverlight 4, en vuestras manos queda darle un toque sofisticado y de ingenio a esta idea inicial.

Vamos a empezar creando un nuevo proyecto de Silverlight 4 en Visual Studio 2010. Una vez realizado nuestro proyecto por defecto, tenemos que extraer un Rss de la página que deseemos. Leer ese Rss, ya que es un archivo XML, transformar cada nodo de ese archivo XML en una cadena y presentarla en el interfaz de usuario.

El primer paso para conseguir nuestra meta, es crear una clase con las propiedades que obtendremos del Rss y que vamos a presentar en cada una de las entradas de la interfaz de usuario. Para ello añadiremos a nuestro proyecto del lado del cliente la siguiente clase(ElementosRSS):

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
 
namespace LeerRSS
{
    public class ElementosRSS
    {
        #region Properties
        public string RSSTitulo { get; set; }
        public Uri RSSEnlace { get; set; }
        #endregion
    }
}

Seguidamente tenemos que añadir una referencia a nuestro proyecto para que pueda leer el archivo XML de la RSS de la página que nosotros decidamos. Presionamos con el botón derecho sobre Referencias y elegimos Agregar Referencia. En la pestaña .NET seleccionamos la referencia System.ServicesModel.Syndication como podemos observar en la siguiente imagen:

No debemos de olvidarnos de añadir las referencia a la librería mencionada con anterioridad en MainPage.xaml.cs, que es el código Behind de la interfaz de usuario de Silverlight:

using System.Xml;
using System.ServiceModel.Syndication;

Dentro del mismo archivo donde hemos incluido las referencia vamos a incluir tres variables. RSSUrl tendrá el valor de la URL de la página de cada una de las entradas del RSS. LectorXML será el encargado de leer el archivo XML que nos ofrece el RSS de la página. Feed que es la encargada de obtener la fuente de sindicación de las diferentes entradas del RSS.

private Uri RSSUrl;
private XmlReader LectorXML;
private SyndicationFeed Feed;

En el constructor(inmediatamente después de InitializaComponent) deberemos añadir el siguiente fragmento de código:

RSSUrl = new Uri(«http://geeks.ms/blogs/rmayo/rss.aspx»);
WebClient client = new WebClient();
client.DownloadStringCompleted += new DownloadStringCompletedEventHandler(client_DownloadStringCompleted);
client.DownloadStringAsync(RSSUrl);

Como podemos observar introducimos la url de la página de la que queremos absorber el RSS. La clase WebClient de Silverlight es la encargada de abrir el RSS(XML).Puesto que la operación se realiza de forma asincrónica se llama al método de devolución de llamada (DownloadStringCompleted) después de realiza dicha operación.

Ahora vamos a encargarnos de crear la interfaz de usuario, para ello nos situamos en MainPage.xaml, e introducimos el siguiente fragmento de código XAML:

<UserControl x:Class=»LectorRSS.MainPage»
    xmlns=»http://schemas.microsoft.com/winfx/2006/xaml/presentation»
    xmlns:x=»http://schemas.microsoft.com/winfx/2006/xaml»
    xmlns:d=»http://schemas.microsoft.com/expression/blend/2008″
    xmlns:mc=»http://schemas.openxmlformats.org/markup-compatibility/2006″
    mc:Ignorable=»d»
    d:DesignHeight=»300″ d:DesignWidth=»400″>
 
    <Grid x:Name=»LayoutRoot»>
        <Grid.Background>
            <LinearGradientBrush EndPoint=»0.5,1″ StartPoint=»0.5,0″>
                <GradientStop Color=»Black» Offset=»0″/>
                <GradientStop Color=»#FFBBB9B9″ Offset=»0.943″/>
            </LinearGradientBrush>
        </Grid.Background>
        <ItemsControl x:Name=»RSS» ItemsSource=»{Binding}« Margin=»163,62,150,113″ >
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <HyperlinkButton x:Name=»Title» NavigateUri=»{Binding RSSLink}«
             Width=»305″ Margin=»0,22,0,15″ Foreground=»#FFD5C214″
             FontSize=»12″ FontWeight=»Bold»>
                        <!–cada una de las entradas de RSS son introducidas en un hyperlink–>
                        <TextBlock  Text=»{Binding RSSTitle}« TextWrapping=»Wrap» FontSize=»18.667″ FontFamily=»Times New Roman» Foreground=»#FF0CB8DC» />
                        <!–cada uno de los hyperlinks mostrará el txto de cada una de las entradas–>
                    </HyperlinkButton>
 
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </Grid>
</UserControl>

Lo que hemos introducido en la interfaz de usuario es una plantilla de datos que nos mostrará cada una de las entradas del RSS,en forma de un Hyperlink.Cada Hyperlink tendrá el titulo de cada una de las entradas de la página de la que obtenemos el RSS.De forma que el usuario al ver cada una de las entradas pueda acceder inmediatamente a ellas.

Ahora, nos centraremos en la creación del método DownloadStringCompleted en MainPage.xaml.cs podemos recuperar el RSS en forma de una cadena. A continuación, podemos crear nuestra XmlReader y cargarlo a una variable de SyndicationFeed que trata el XML como un ‘RSS’ y nos permite utilizar sus propiedades:

 private void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            if (e.Error == null)
            {
                int itemsCount = 5;//número de entradas del RSS
                LectorXML = XmlReader.Create(new StringReader(e.Result));//lector de XML
                Feed = SyndicationFeed.Load(LectorXML); //se introduce el XML en una variable 
                //de tipo SyndicationFeed
 
                List<ElementosRSS> itemsList = new List<ElementosRSS>();//creamos una colección 
                //para introducir los 5 elementos del RSS
 
                if (Feed.Items.Count() < 5)
                {
                    itemsCount = Feed.Items.Count();
                }
 
                for (int i = 0; i <= itemsCount; i++)
                {
                    ElementosRSS rssitem = new ElementosRSS();
                    rssitem.RSSTitulo = Feed.Items.ToList()[i].Title.Text;
                    rssitem.RSSEnlace = Feed.Items.ToList()[i].Links[0].Uri;
                    //introducimos cada una de las propiedades en cada uno de los items de la colección de objetos
                }
                RSS.ItemsSource = itemsList;
            }
        }

El último paso es introducir una referencia a nuestro proyecto, para que este consiga leer el archivo xml, podemos introducir la referencia de dos formas:

1-introduciendo de forma manual la referencia

using System.IO;

2-Situandonos sobre el elemento que demanda dicha librería y eligiendo la opción de añadirla que nos ofrece el Itelligence de Visual Studio 2010 como podemos observar en la siguiente imagen:

Ahora ya tenemos creado un simple lector de RSS, que nos muestra las diferentes entradas de mi blog. Presionando sobre ellas accederéis al artículo en concreto como podéis observar en la siguiente imagen:

Aunque sea un proyecto simple podemos ampliar sus posibilidades, mostrando un resumen de cada uno de los artículos o utilizando dicho proyecto para formar parte de un Webpar en SharePoint, así que la elección la dejo en vuestras manos.

Implementar R.I.A. Services a tu web con Silverlight 4

Cada vez más se tiende a enriquecer nuestras aplicaciones, de forma que deseamos tener todas aplicaciones de negocio en el mundo web. Para lograr una experiencia de usuario enriquecedora a la par que productiva vamos a utilizar Silverlight 4 y los servicios R.I.A que esta plataforma nos ofrece.

Pero para empezar a trabajar con estos elementos lo mejor es que comencemos por comprender el termino R.I.A de Silverlight 4. Que mejor forma de comenzar el aprendizaje que saber el significado de R.I.A. (Rich Internet Application) en definitiva aplicaciones enriquecidas de internet. Pero nos nos vamos a quedar en el termino de la parte visible y bonita de este concepto, si no que vamos a entrar en la parte funcional y productiva del mismo.

El siguiente paso es la visualización de la estructura de las webs tradicionales y las web que utilizan R.I.A Services:

Web tradicionales

Las webs tradicionales por un lado tenían el navegador basado exclusivamente en HTML alojado en el navegador y por el otro las diferentes capas de la aplicación( Presentación, lógica y de Acceso a Datos). Lo que conlleva pesados desarrollos del lado del servidor, además del retardo en el tiempo de respuesta a la hora de trabajar con los datos contenidos en el servidor.

Aplicaciones R.I.A

Las aplicaciones R.I.A lo que hacen es separar la capa de presentación al lado del cliente, consiguiendo con ello un cliente mucho más versátil, eso si, también más pesado. La mayor dificultad la encontramos en que las comunicaciones con las fuentes de datos no se realizan de manera directa y ¿cómo resolvemos este problema?

En Silverlight 4 se introducen dos nuevos elementos (Domain Context y el Data Services) que nos ayudan a resolver el problema mencionado con anterioridad, convirtiendo nuestra aplicación en una web tradicional pero aprovechando todas posibilidades que nos ofrecen los servicios RIA.

Vamos a entrar en detalles, el elemento Data Services está situado del lado del servidor y nos va servir de nexo entre el cliente y la fuente de datos. El elemento Domain Context está situado del lado del cliente. Nos permite trabajar con los datos del servidor y utilizarlos en la capa de presentación. Estos dos elementos se asemejan a los conocidos DataSources de ASP.Net. Pudiendo realizar inserciones, actualizaciones, borrados, filtros, etc.

Una vez que hemos comprendido el concepto de los servicios R.I.A vamos aplicarlos en un proyecto de Silverlight 4. Para este ejemplo hemos utilizado Visual Studio 2010 Beta 2 y Silverlight 4 Beta.

Abrimos Visual Studio 2010 para crear un nuevo proyecto Silverlight 4 eligiendo como plantilla “Silverlight Business Application”como podemos observar en la siguiente imagen:

Ahora vamos a implementar los servicios R.I.A para poder disfrutar trabajando con ellos. Lo primero es agregar la fuente de datos con la que vamos a trabajar, para ello nos situamos del lado del servidor (nombre del proyecto.Web) y presionando con el botón derecho sobre la carpeta Models elegimos Añadir->Nuevo Elemento.

En mi caso voy a utilizar como modelo de obtención de datos ADO:NET Entity Data Model pero podríais utilizar el modelo que más se adapte a vuestras necesidades.

Una vez seleccionado el elemento, elegimos un nombre representativo y presionamos aceptar. En la siguiente ventana emergente elegimos Generar desde una base de datos, ya que esta va ser el tipo de fuente de datos.

En la siguiente ventana emergente, seleccionamos Nueva Conexión, nos aparecerá una nueva ventana en la que debemos hacer clic en el área fuente de datos sobre el botón Cambiar.

Nos surge una nueva ventana, en la que elegimos el tipo de base de datos con la que queremos trabajar. En mi caso voy a trabajar con una base de datos propia, así que elijo Microsoft SQL Server Database File, pero podéis utilizar la conocida Northwind, eligiendo la misma opción que yo he elegido.

Presionamos Aceptar, hacemos clic sobre el botón Buscar y elegimos la base de datos sobre la que queremos trabajar, presionamos Aceptar y Siguiente.

En la siguiente ventana emergente aparecen los elementos sobre los que queremos trabajar, en nuestro ejemplo vamos a trabajar sobre la tabla Productos.

Presionamos Finalizar e inmediatamente Visual Studio nos muestra el diagrama de la fuente de datos seleccionada.

Como ultima acción que realizaremos es construir nuestra solución (F6 en Visual Studio), para que podemos utilizar la fuente de datos.

Ahora vamos a centrarnos en el Domain Context, dicho elemento nos permitirá trabajar con las distintas entidades de la base de datos de nuestro proyecto. Para ello a desde el lado del servidor vamos añadir un nuevo elemento en la carpeta Services. En este caso vamos agregar el objeto Domain Service Class, que se encuentra situado en las plantillas web como podemos en la siguiente imagen:

Elegimos un nombre representativo del objeto (en mi caso StockProDomainService.cs, ya que vamos a representar una serie de productos) y finalmente presionamos sobre el botón Añadir para crear el objeto.

Al realizar dicha acción nos aparecerá una ventana emergente.En dicha ventana aparece el nombre del DomainService, además tendremos la opción de permitir acceso a dicho servicio desde el lado del cliente, opción que deberemos dejar seleccionada. Por otro lado te permite seleccionar la fuente de datos sobre la vamos a manipular las distintas entidades. En nuestro caso la fuente de datos será la creada con anterioridad, pero podríamos crear un servicio para cada fuente de datos. Además aparecerá un área donde estarán las diferentes entidades sobre las que vamos a trabajar.Deberemos seleccionar las que deseemos, así como la opción de permitir la edición de dichas entidades. Por último tenemos la opción de generar las clases correspondiente para generar metadatos, dicha opción es aconsejable seleccionarla para validar datos de entrada. En el proyecto que nos ocupa no tiene relevancia, pero si que podrá utilizarse en posteriores proyectos, así que la seleccionaremos. Este será el aspecto que tendrá nuestra ventana emergente:

Presionamos el botón aceptar y podemos ver como nuestro servicio de dominio está formado por los métodos de edición(Insertar, Actualizar y Borrar) de la entidad Productos. También podemos ver como nuestra clase (StockProDomainService), se encuentra instanciada a través de LINQ debido a que cualquier lectura o escritura de la fuente de datos se va a realizar a través de LINQ.

Para obtener los datos de la fuente de datos y utilizarlos del lado del cliente tenemos el método

 public IQueryable<Productos> GetProductos()
        {
            
            //query que obtiene los datos indicados de la fuente de datos
            return this.ObjectContext.Productos;
                
        }

que nos permite realizar una consulta obteniendo los datos que deseemos, aplicándole los filtros correspondientes. En nuestro caso vamos a obtener los 30 primeros productos y los vamos a ordenar por el identificador del producto(IDPRODUCTO), de manera que nuestro método quedará del siguiente modo:

public IQueryable<Productos> GetProductos()
        {
            
            //query que obtiene los datos indicados de la fuente de datos
            return this.ObjectContext.Productos
                  .OrderBy(orden => orden.IDProducto)
                  .Where(emp => emp.IDProducto >= 1 & emp.IDProducto <= 30);
                
        }

Ahora vamos a trasladar los datos obtenidos a la interfaz de usuario.Para ello abrimos Home.Xaml, que es el archivo encargado de gestionar lo referente a la interfaz de usuario en nuestra página principal.Este elemento está situado en la carpeta Views de nuestro proyecto del lado del cliente. En la barra de herramientas de Visual Studio 2010, escogeremos el objeto DataGrid y lo desplazaremos a el área de diseño. Como podemos observar en la siguiente imagen le hemos dado el tamaño y situación de dicho objeto a nuestro criterio.

Seguidamente vamos a enlazar la base de datos con el DataGrid. En esta nueva versión de Silverlight y Visual Studio conseguimos realizar este paso a un solo clic, sin necesidad de escribir código como en visual Studio 2008. Para ello vamos a menú Datos y elegimos mostrar fuentes de datos.

Al realizar dicha acción aparecerá un nuevo menú, en el se presentan las distintas fuentes de datos como el registro de usuarios, registro del contenido de cada usuario, etc.. Pero la parte que nos interesa es nuestro StockProDomainContext y su entidad Productos.

Seleccionamos la entidad Productos y la arrastramos al interior de el objeto DataGrid que se añadió con anterioridad. Al realizar este paso se a generado en Home.xaml el siguiente código:

<riaControls:DomainDataSource AutoLoad=»True» Height=»0″ LoadedData=»productoDomainDataSource_LoadedData» Name=»productoDomainDataSource» QueryName=»GetProductosQuery» Width=»0″>
    <riaControls:DomainDataSource.DomainContext>
        <my:StockProDomainContext />
    </riaControls:DomainDataSource.DomainContext>
</riaControls:DomainDataSource>

Dicho código realiza la carga de los diferentes datos de la fuente de datos a través del método GetProductosQuery perteneciente al StockProDomainContext.

Ahora lo que tenemos que realizar es adaptar de forma correcta nuestro DataGrid para que muestre los datos de forma correcta. Seleccionamos dicho objeto en el área de diseño y modificamos las siguientes propiedades:

Width:Auto
Height:Auto
AutoGenerateColumns:True, esta propiedad permitirá la creación de columnas correspondientes a los campos de la entidad.

Ejecutamos el proyecto F5 y podemos comprobar como se cargan los 30 primero productos ordenados por IDProducto de la Base de datos.

Para no quedarnos solo con la simple carga de datos en nuestro DataGrid, vamos a cargar todos los elementos de la fuente de datos. Para filtrar los elementos en paginas de 20 elementos cada una.

Lo primero de todo nos desplazaremos StockProDomainService.cs y accedemos a el método GetProductos() y eliminamos parte de la consulta para que se carguen todos los datos, siendo el código resultante del método el siguiente:

 public IQueryable<Productos> GetProductos()
        {
            
            //query que obtiene los datos indicados de la fuente de datos
            return this.ObjectContext.Productos
                
                .OrderBy(orden => orden.IDProducto);
                
        }

Ahora volvemos a la interfaz de usuario (Home.Xaml) para introducir en esta un nuevo elemento. Nos situamos en la barra de herramientas y sobre el área General presionamos con el botón derecho sobre dicha área, para seleccionar Elegir Elemento, como podemos ver en la siguiente imagen:

Al elegir esta opción surgirá una ventana emergente en la que elegiremos DataPager dentro del área de búsqueda:

De este modo ya tenemos agregado dicho elemento a nuestra barra de herramientas, ahora debemos arrastrarlo a la inferior del DataGrid y establecemos las siguientes propiedades para el objeto DataPager:

Width:Auto
PageSize:20 para cargar 20 elementos en cada página

El siguiente paso es volver a el menú Fuente de datos y seleccionar la entidad Productos e incluirla dentro del control DataPager (este paso es similar al que hemos hecho con el DataGrid). Ahora para ver la agrupación de todos los datos de 20 en 20 elementos deberemos ejecutar el proyecto y el resultado será el de la siguiente imagen:

Como podemos observar gracias a los servicios R.I.A. de Silverlight 4 y Visual Studio 2010 podemos exprimir al máximo todas las características que nos ofrecen nuestras bases de datos y todo a unos simples clics de ratón. Esta solo es una pequeña muestra del potencial de esta parte de la plataforma, debido a que hay infinidad de características que puedes agregar a tus aplicaciones Silverlight, iremos poco a poco descubriéndolas en posteriores artículos.

Ampliar la perspectiva de tu Web con Deep Zoom Composer & Silverlight 3

Todos hemos visitado alguna web, en busca de un catálogo de productos. Cierto es, que a veces, nos gustaría tener de un solo vistazo todos los productos, para que más tarde pudiéramos seleccionar el deseado. Pero esto supondría tener un catálogo de dimensiones considerables.

En este artículo propongo una idea para conseguir que todo un catálogo de artículos esté disponible a la vista del usuario, eso sí, sin ocuparnos la pantalla por completo. Además dando la posibilidad de ver al detalle la imagen de cada uno de los artículos, simplemente con el scroll del ratón. Pero para conseguir este objetivo necesitamos la ayuda de dos brazos fuertes y ágiles, informáticamente hablando claro. Usaremos Silverlight 3 y Deep Zoom Composer.

Comenzamos abriendo Deep Zoom Composer, en la ventana inicial del programa elegimos nuevo proyecto, otorgando el nombre y la ubicación del mismo como podemos observar en la imagen:

Ahora importamos las imágenes, que van a ser el catálogo de los distintos artículos que vamos a ofrecer al usuario. En mi caso he elegido como artículos bicicletas y accesorios de las mismas. Para importar elegimos de las tres pestañas situadas en la parte superior la de Importar.

Luego haremos clic sobre añadir imágenes y seleccionamos las diferentes imágenes.

Una vez tengamos las imágenes seleccionadas vamos a componer nuestra imagen final. Para ellos seleccionamos la pestaña Componer. Seleccionamos las imágenes que se encuentran en la parte inferior de la pantalla y las arrastramos al área de diseño como podemos observar en la siguiente imagen:

Al importar las imágenes al área de diseño de la imagen final, estas se encuentran de forma desorganizada. Afortunadamente las podemos ordenar haciendo clic con el botón derecho sobre ellas y eligiendo Organizar->Organizar en un Grid.

Nos aparecerá una nueva ventana emergente en la que se ofrece la posibilidad de alinear las distintas fotografías. En mi caso elegiré la opción restringir por filas puesto que deseo alinear las diferentes imágenes de forma vertical. El número de filas que utilizo son cinco y el Pading tomará el valor cero, debido que no quiero que haya separación entre las diferentes columnas. Esta configuración la podéis variar a vuestro antojo, además antes de confirmar podéis aplicar las distintas configuraciones y ver de forma previa la composición de las distintas imágenes.

Presionamos ok y se realizarán los correspondientes cambios.

Es hora de realizar la exportación de nuestra composición de imágenes. Seleccionamos la pestaña Exportar de la parte superior del programa. Elegimos la pestaña personalizado en la parte derecha del programa y elegimos el formato Silverlight Deep Zoom. Introducimos un nombre para la composición y la ubicación de la misma. Por otro lado elegimos la plantilla Deep Zoom Navigation, que es la plantilla por defecto del programa. El formato es JPG la calidad 95 y el tamaño es de 800. Presionamos OK y se exportará nuestra composición de imágenes.

También tenemos la posibilidad de pre visualizar la composición final antes de exportarla, si la pre visualización de la composición es correcta, presionamos Exportar y se realizará la acción.

Ahora vamos a realizar la segunda parte del proyecto, que es la creación de una aplicación Silverlight en la que vamos a incluir la composición de imágenes creada con anterioridad. A su vez le otorgaremos las funcionalidades para que el usuario pueda visionar con todo detalle cada producto.

Abrimos Visual Studio 2008, seleccionamos Proyecto->Nuevo Proyecto. En la ventana emergente seleccionamos Silverlight en el área Tipo de Proyecto. Seguidamente en el área de plantillas elegimos Aplicación Silverlight. Introducimos el nombre del proyecto y la ubicación presionamos Aceptar y se creará un nuevo proyecto Silverlight 3.

Una vez construido nuestro proyecto debemos construir una nueva solución F6. De este modo se cargará el archivo .xap del lado del cliente, dentro de la carpeta BIN. Nos situamos en el proyecto creado con anterioridad de Deep Zoom Composer. Copiamos la carpeta GeneratedImages en la carpeta BIN.

Ahora vamos a introducir el objeto que nos permite en .Net escalar las imágenes. Para ello abrimos el archivo MainPage.xaml e introducimos el citado objeto como podemos observar en el siguiente fragmento de código:

Code Snippet

<UserControl x:Class=»CatalogoArticulos.MainPage» 
   xmlns=»http://schemas.microsoft.com/winfx/2006/xaml/presentation» 
   xmlns:x=»http://schemas.microsoft.com/winfx/2006/xaml» 
   xmlns:d=»http://schemas.microsoft.com/expression/blend/2008″ xmlns:mc=»http://schemas.openxmlformats.org/markup-compatibility/2006″ 
   mc:Ignorable=»d» d:DesignWidth=»640″ d:DesignHeight=»480″> 
        <Grid x:Name=»LayoutRoot»> 
            <MultiScaleImage x:Name=»Escalar» Source=»../GeneratedImages/dzc_output.xml»/> 
        </Grid> 
    </UserControl> 

Como podemos observar el origen del objeto que nos permite escalar las diferentes imágenes, lo obtenemos de la carpeta previamente copiada. En concreto del archivo dzc_output.xml. Que es la composición de imágenes exportadas en la primera parte de este artículo.

Si ejecutamos el proyecto (F5), podemos observar como se cargan las imágenes pero lamentablemente no tenemos control sobre los eventos del ratón para poder aumentar las imágenes y verlas con todo detalle.

Es por esta razón que debemos abrir el archivo MainPage.xaml.cs e incluir el siguiente fragmento de código para poder controlar los distintos comportamientos del objetos escalar:

Code Snippet

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Net; 
using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Documents; 
using System.Windows.Input; 
using System.Windows.Media; 
using System.Windows.Media.Animation; 
using System.Windows.Shapes; 
  
namespace CatalogoArticulos 
{ 
    public partial class MainPage : UserControl 
    { 
        double zoom = 1; 
        bool duringDrag = false; 
        bool mouseDown = false; 
        Point lastMouseDownPos = new Point(); 
        Point lastMousePos = new Point(); 
        Point lastMouseViewPort = new Point(); 
  
  
        public double ZoomFactor 
        { 
            //establecimiento del valor de ampliación 
            get { return zoom; } 
            set { zoom = value; } 
        } 
        public MainPage() 
        { 
            InitializeComponent(); 
            //controlar el movimiento decendente del ratón 
            //al presionar el botón izquierdo 
            this.MouseLeftButtonDown += 
        delegate(object sender, MouseButtonEventArgs e) 
        { 
            lastMouseDownPos = e.GetPosition(Escalar); 
            lastMouseViewPort = Escalar.ViewportOrigin; 
  
            mouseDown = true; 
  
            Escalar.CaptureMouse(); 
        }; 
            //controlar el movimiento ascendente del ratón 
            //al presionar el botón izquierdo 
            this.MouseLeftButtonUp += delegate(object sender, MouseButtonEventArgs e) 
            { 
                if (!duringDrag) 
                { 
                    bool shiftDown = 
                      (Keyboard.Modifiers & ModifierKeys.Shift) == ModifierKeys.Shift; 
                    double newzoom = zoom; 
  
                    if (shiftDown) 
                    { 
                        newzoom /= 2; 
                    } 
                    else 
                    { 
                        newzoom *= 2; 
                    } 
  
                    Zoom(newzoom, Escalar.ElementToLogicalPoint(this.lastMousePos)); 
                } 
                duringDrag = false; 
                mouseDown = false; 
  
                Escalar.ReleaseMouseCapture();//actualización del objeto que nos permite escalar las imagenes 
            }; 
            //localizamos la posición del puntero 
            //a trevés del evento MouseMove 
            this.MouseMove += delegate(object sender, MouseEventArgs e) 
            { 
                lastMousePos = e.GetPosition(Escalar); 
                if (mouseDown && !duringDrag) 
                { 
                    duringDrag = true; 
                    double w = Escalar.ViewportWidth; 
                    Point o = new Point(Escalar.ViewportOrigin.X, Escalar.ViewportOrigin.Y); 
                    Escalar.UseSprings = false; 
                    Escalar.ViewportOrigin = new Point(o.X, o.Y); 
                    Escalar.ViewportWidth = w; 
                    zoom = 1 / w; 
                    Escalar.UseSprings = true; 
                } 
  
                if (duringDrag) 
                { 
                    Point newPoint = lastMouseViewPort; 
                    newPoint.X += (lastMouseDownPos.X – lastMousePos.X) / 
                      Escalar.ActualWidth * Escalar.ViewportWidth; 
                    newPoint.Y += (lastMouseDownPos.Y – lastMousePos.Y) / 
                      Escalar.ActualWidth * Escalar.ViewportWidth; 
                    Escalar.ViewportOrigin = newPoint; 
                } 
            }; 
            //llamada a la clase Helper con los paremetros de aumento 
            new MouseWheelHelper(this).Moved += 
              delegate(object sender, MouseWheelEventArgs e) 
              { 
                  e.Handled = true; 
  
                  double newzoom = zoom; 
  
                  if (e.Delta < 0) 
                      newzoom /= 1.3; 
                  else 
                      newzoom *= 1.3; 
  
                  Zoom(newzoom, Escalar.ElementToLogicalPoint(this.lastMousePos)); 
                  Escalar.CaptureMouse(); 
              }; 
        } 
        //rango de aumento 
        private void Zoom(double newzoom, Point p) 
        { 
            if (newzoom < 0.5) 
            { 
                newzoom = 0.5; 
            } 
  
            Escalar.ZoomAboutLogicalPoint(newzoom / zoom, p.X, p.Y); 
            zoom = newzoom; 
        } 
    } 
} 

En este fragmento de código se hace una llamada a la clase MouseWheelHelper, que permite realizar el escalado de las diferentes imágenes. El contenido de esta clase lo podéis descargar aquí. Ahora solo tenemos que situarnos en nuestro proyecto, presionar sobre él con el botón derecho y elegir Añadir->Nuevo elemento.

Seguidamente en la ventana emergente en el área de plantillas elegimos la plantilla clase y la nombramos como MouseWheelHelper.cs.

Dentro de la misma incluiremos el contenido de la clase que hemos descargado con anterioridad. De esto modo conseguiremos que nuestro proyecto controle los eventos del ratón de forma correcta.

Finalmente ejecutamos nuestra aplicación F5, podemos observar tenemos todo el catálogo de artículos en una sola vista, si bien es cierto que podemos aumentar cada articulo y verlo con detalle sin perder calidad a la hora de realizar dicha acción.

De este modo podemos crear aplicaciones, en las que necesitemos un reducido espacio a la hora de situarlo en nuestra web. Sin embargo no ofreceremos posibilidad al usuario para poder tener una vista diferente de los distintos artículos que se ofertan en la misma. Todo utilizando la eficiencia de Silverlight 3 y la flexibilidad y creatividad de Deep Zoom Composer.

Problema Al actualizar Silverlight 3 “unable to start debugging Silverlight”

Recientemente he tenido un problema al actualizar Silverlight 2 a Silverlight 3. He instalado todos los programas y complementos que requiere Microsoft desde la página de inicio de Silverlight 3 get started. He creado diversos proyectos y hasta aquí no tengo ningún problema pero cuando trato de depurar mis proyectos me ocurre el error “unable to start debugging Silverlight”

El problema radicaba en que tenía distintas versiones del SDK instaladas en mi equipo.

La solución pasa por desinstalar el SDK de Silverlight 2 y el plugin de la misma versión e instalar las Silverlight 3 Tools for visual Studio 2008 sp1, de este modo la próxima vez que depure mi proyecto no tuve ningún problema.

Como restaurar la plantilla Directorio de Sitios en Sharepoint 2010

SharePoint 2010 por defecto no aparece la plantilla Site Directory, esto nos causa un grave problema a la hora haber realizado una migración de 2007, ya que debemos tener visible esta plantilla si queremos crear un nuevo sitio basándonos en alguna plantilla de SharePoint 2007.

La plantilla Site Directory no es que no esté en SharePoint 2010 si no que está oculta. ¿Cómo solucionamos este problema?

Deberemos entrar en el directorio donde está situado el ejecutable stsadm a trevés de una consola de comandos
Activamos la característica "PublishingLayout" a trevés del siguiente comando:

stsadm.exe -o activatefeature -id 5F3B0127-2F1D-4cfd-8DD2-85AD1FB00BFC

Seguidamente ya puedes crear el directorio de sitios:

stsadm.exe -o createweb -url http://sitedirectory -sitetemplate spssites#0 -title "Site Directory"

Silverlight 4

El PDC de este año ha estado cargado de un gran número de novedades (Office 2010, SharePoint2010,Visual Studio 2010,etc.). Personalmente me quedo con el lanzamiento de Silverlight 4. ¿Por qué? Porque cada vez está al mismo nivel que sus competidores, porque es una plataforma en la que cada vez se incluyen más características de su hermano de escritorio (WPF). Esta versión de Silverlight viene cargadita de controles y características nuevas:

Integración completa del diseñador en Visual Studio 2010, gracia a la existencia de un área de diseño que no solo está disponible para Silverlight 4 si no que en su antecesor también contamos con ella.
API de Impresión, permite al desarrollador tener el control de las distintas características del área de impresión a través de un árbol visual, también puede controlar la pre y post impresión.
Control del evento del botón derecho del ratón, lo que nos permite por ejemplo cambiar de estilo a un control.
Acceder a características de la Webcam y el Micrófono, solo con obtener permisos del usuario puedes acceder al micrófono y la Web Cam, además de poder tomar instantáneas de esta última.
Soporte Nativo para la Rueda del Ratón, a través de una nueva API que permite manejar este elemento del ratón de forma independiente y no depender de terceros como algunas características de DeepZoom, etc…
RichTextArea, este control es uno de los más solicitados, al ofrecernos la posibilidad de editar cualquier texto de forma enriquecida, mediante la activación de comandos como Negrita, Cursiva, Corrector ortográfico, etc…
API Portapapeles, la inclusión de este api, nos evita depender de otras plataformas para tener acceso al área de memoria reservada para este fin.
Mostrar HTML a través de el control WebBrowser, permite introducir contenido HTML en el control Silverlight 4 a través de un simple control WebBrowser, o por ejemplo utilizar una Url interactiva de un video de Youtube que se reproduzca dentro de nuestro control Silverlight 4.
Privilegios elevados para aplicaciones OOB, las aplicaciones Out Of Browser que Silverlight 3 incorporaba como novedad siempre requerían elevar privilegios, con esta nueva versión podemos otorgarlos si lo creemos convenientes.
Acceso a ficheros locales, en versiones anteriores solo podíamos tener acceso a ficheros locales a través de OpenFileDialog(lectura),SaveFileDialog(Escritura). Ahora podemos tener acceso a ficheros locales situados en las carpetas «My» que cada usuario tiene en su perfil, como por ejemplo «Mis documentos», «Mi Música», etc..Esta característica requiere permisos elevados.
Interoperabilidad COM, si nuestras aplicaciones Silverlight necesitan comunicarse con aplicaciones Office o con periféricos que solo usan interfaz COM. Ahora pueden hacerlo simplemente creando una instancia de la API ComAutomationFactory.
Notificaciones de escritorio(tipo MSN u Outlook), las características que nos ofrece MSN u Outlook en cuanto a mensajes emergentes en el escritorio al recibir un nuevo correo, un mensaje instantáneo etc.. ahora están disponibles a través de un API dedicada para este fin.
Autentificación de Red, a veces necesitamos autentificar las llamadas de servicios para consumir unos determinados recursos. Puede que la persona que los reclama no sea la misma que los reclamaba con anterioridad. Para facilitar esta información disponemos de NetworkCredential a través de pila de red ClientHttp.
Cambios en el Acceso Cross Domain, uno de los cambios más significativos para redes de dominios llega cuando tiene una aplicación de confianza. Los servicios que tienen un archivo de política de dominios cerrado (mediante clientaccesspolicy.xml o crossdomain.xml), si la aplicación es una aplicación de confianza (permisos elevados), el requisito de un archivo de política de dominios ya no es necesario.
Disponibilidad de todo el teclado en aplicaciones de pantalla completa, en aplicaciones que se ejecutan en pantalla completa como en supermercados, tiene limitado el teclado a unas determinadas teclas, ahora permite tener disponible todo el teclado por ejemplo en controles como un textbox.
Text trimming, los textbox tienen esta nueva propiedad que permite utilizar el valor WordElipse, de modo que si el texto introducido supera la superficie del control se mostrarán puntos suspensivos en el límite de dicho control.
View Box en el núcleo de Silverlight, debido a la importancia que ha tomado este control está disponible en el núcleo de esta plataforma.
DRM sin conexión, la próxima generación de PlayReady se centra en tres modelos de negocio el alquiler, la compra y la suscripción que nosotros podremos realizar en modo Off-line.
Contenido protegido H264, como ha venido demostrando Silverlight ofrece una protección en el contenido Playready para medios codificados de esta plataforma y VC1. Pero ahora ofrece esta posibilidad a los medios de comunicación H.264.
Arrastrar archivos a la aplicación Silverlight, cuantas veces queremos arrastrar archivos a nuestra aplicación Silverlight, ahora podemos mediante la activación del atributo AllowDrop en los elementos de la interfaz del usuario.
Validación Asíncrona e IDataErrorInfo, Silverlight permite a través de IDataErrorInfo la realización de informes de errores de validación que pueden ser enlazados de una interfaz de usuario. Cuando una interfaz está implicada en dicho enlace, esta invoca al indexador para validar las propiedades. Si tenemos ValidatesOnDataErrors como verdadero, las propiedades de destino en la interfaz de usuario recibirán mensajes de error y mostrarán mensajes de error.

IDataErrorInfo se limita a validar propiedades básicas. INotifyDataErrorInfo permite la validación de todas las propiedades de una entidad, además de prestar validación asincrónica para acceder a la lógica de validación en el servidor. De este modo contaremos con una propiedad HasErrors para indicarnos si contiene algún error y el método GetErrors para recuperar los errores.
Enlace de Objetos dependientes, Silverlight introduce la capacidad de enlazar propiedades en un DependencyObject (DO) y no sólo en FrameworkElements.
StringFormat, TargetNullValue, FallbackValue, en ocasiones generar formatos en el enlace de datos no resulta tan sencillo si no es una operación simple (formato moneda,fechas, etc.) A partir de esta versión disponemos de String Format para dar formato directamente a nuestros datos enlazados o el formato de salida de un campo. Fallbackvalue muestra un valor cuando la operación de enlace de datos no se ha realizado de forma satisfactoria. Cuando el valor del enlace de datos es null TargetNullValue nos proporciona un valor.
Managed Extensibility Framework (MEF), esta propiedad es incorporada en el SDK de Silverlight 4 debido a que abarca un amplio campo, podréis encontrar una amplia información de esta propiedad aquí.
Soporte para Fluid UI, para agregar experiencias más dinámicas a la interfaz de usuario se han agregado nuevos estados a los ItemControl. Estos nuevos estados (BeforeLoaded, Loaded y unloaded) ayudan a animar la transición de contenidos entre Estados en un ItemsControl .
Temas Implicitos, Silverlight 4 permite crear un estilo como un recurso que puede ser utilizado implícitamente por todos los elementos de un tipo de destino. Esto permite que los desarrolladores de aplicaciones personalicen el aspecto a través de varias instancias de un control y modificar la apariencia de estas instancias de control cambiando el estilo implícito.
Soporte para Google Chrome, hasta la actualidad Silverlight podía ejecutarse en Chrome pero no de manera oficial, a partir de esta versión se ha creado un grupo de trabajo entre Microsoft y Google para que Silverlight se ejecute sin contratiempos.

Como podréis ver Silverlight 4 tiene unas cuantas novedades para estar jugando un buen ratos, cuidado que engacha!!

Un último apunte aquí tenéis las descargas que necesitais para trabajar con esta nueva versión:

Visual Studio 2010 Beta 2
Silverlight Tools for Visual Studio 2010
Expression Blend for .NET 4 Preview
WCF RIA Services
Silverlight 4 SDK CHM(documentación)
Silverlight 4 Toolkit
Developer runtimes: Windows
Silverlight 4 SDK only( no es necesario si instala las herramientas anteriores)

Silverlight Media Framework(un nuevo, marco de Reproductor de medios de comunicación de código)