Numeración de líneas en el editor de texto de Visual Studio 2010

Una de las cosas que echaba de menos en Visual Studio 2010 y que no aparece de forma predeterminada, es la posibilidad  de ver el número de línea en el que nos encontramos.

image 

Esta capacidad nos permite acceder de forma rápida y precisa a un error que se ha producido, cuando realizamos pruebas de testeo de nuestras aplicaciones, etc..

Para utilizar la numeración de líneas en Visual Studio 2010, accedemos a Herramientas->Opciones

image

En Opciones expandiremos Editor de Texto->Expandiremos C#

image

Dentro de la pestaña General, tendremos que seleccionar Números de Línea.

image

De este modo podremos inmediatamente utilizar esta propiedad de Visual Studio 2010!!!!!

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:

image

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:

image

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.

image

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).

image

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

image

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.

image

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:

image

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:

image

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:

  1.     <Grid.Background>
  2.         <LinearGradientBrush EndPoint=”0.5,1″ StartPoint=”0.5,0″>
  3.             <GradientStop Color=”Black” Offset=”0″ />
  4.             <GradientStop Color=”White” Offset=”1″ />
  5.         </LinearGradientBrush>
  6.     </Grid.Background>
  7. </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:

image

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:

image

Presionamos Ok para realizar la correspondiente acción.

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

  1. <?xml version=1.0 encoding=utf-8?>
  2. <Elements xmlns=http://schemas.microsoft.com/sharepoint/>
  3.   <Module Name=ModuloSilverlight Url=StoreSilverlight>
  4.     <File Path=ModuloSilverlightAplicacionSilverlight.xap Url=AplicacionSilverlight.xap Type=GhostableInLibrary/>
  5.   </Module>
  6. </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:

image

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

image

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:

image

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

image

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

image 

 

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:

  1. using Microsoft.SharePoint.Client;

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

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

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

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

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:

  1. <Grid x:Name=”LayoutRoot”>
  2.         <Grid.Background>
  3.             <LinearGradientBrush EndPoint=”0.5,1″ StartPoint=”0.5,0″>
  4.                 <GradientStop Color=”Black” Offset=”0″ />
  5.                 <GradientStop Color=”White” Offset=”1″ />
  6.             </LinearGradientBrush>
  7.         </Grid.Background>
  8.         <StackPanel Orientation=”Horizontal” >
  9.             <ListBox Name=”lbLists” Width=”300″ Height=”400″ ScrollViewer.VerticalScrollBarVisibility=”Auto” Margin=”20,20,20,20″ />
  10.             <TextBox Name=”txtDetails” Width=”200″ Height=”400″ TextWrapping=”Wrap” />
  11.         </StackPanel>
  12.     </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.

  1. private Microsoft.SharePoint.Client.Web _sitio;
  2. 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:

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

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

  1. private void OnRequestSucceeded(Object sender, ClientRequestSucceededEventArgs args)
  2. { //si la petición se a realizada correctamente se llama al método FillList
  3.     Dispatcher.BeginInvoke(FillList);
  4. }
  5.  
  6. private void OnRequestFailed(Object sender, ClientRequestFailedEventArgs args)
  7. {
  8. }
  9. private void FillList()
  10. {
  11.     //borra el listbox con los contenidos que tenia anteriormente
  12.     lbLists.Items.Clear();
  13.     lbLists.ItemsSource = _sitio.Lists;
  14.     //se carga en el listBox las diferentes listas
  15.     lbLists.DisplayMemberPath = “Title”;
  16.     //se muestra el campo de la lista que se va mostrar
  17. }

 

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:

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

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

  1.         private void ShowListDetails()
  2. {
  3.     string infoAboutList =
  4.         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}”,
  5.         _list.Title + Environment.NewLine,
  6.         _list.Description + Environment.NewLine,
  7.         _list.ItemCount + Environment.NewLine,
  8.         _list.BaseTemplate + Environment.NewLine,
  9.         _list.BaseType + Environment.NewLine,
  10.         _list.ContentTypesEnabled + Environment.NewLine,
  11.         _list.Hidden + Environment.NewLine);
  12.  
  13.     txtDetails.Text = infoAboutList;
  14. }

 

 

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:

image

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

image

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:

  1. PrintDocument docToPrint = new PrintDocument();
  2. 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:

  1. PrintDocument docToPrint = new PrintDocument();
  2. 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

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

En la versión RC

  1. docToPrint.BeginPrint += (s, args) =>
  2.     {
  3.         ActivityDisplay.IsActive = true;
  4.         
  5.     };

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

msBreak10

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):

image

  1. using System;
  2. using System.Net;
  3. using System.Windows;
  4. using System.Windows.Controls;
  5. using System.Windows.Documents;
  6. using System.Windows.Ink;
  7. using System.Windows.Input;
  8. using System.Windows.Media;
  9. using System.Windows.Media.Animation;
  10. using System.Windows.Shapes;
  11.  
  12. namespace LeerRSS
  13. {
  14.     public class ElementosRSS
  15.     {
  16.         #region Properties
  17.         public string RSSTitulo { get; set; }
  18.         public Uri RSSEnlace { get; set; }
  19.         #endregion
  20.     }
  21. }

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:

image

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:

 

  1. using System.Xml;
  2. 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.

  1. private Uri RSSUrl;
  2. private XmlReader LectorXML;
  3. private SyndicationFeed Feed;

 

 

 

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

  1. RSSUrl = new Uri(“http://geeks.ms/blogs/rmayo/rss.aspx”);
  2. WebClient client = new WebClient();
  3. client.DownloadStringCompleted += new DownloadStringCompletedEventHandler(client_DownloadStringCompleted);
  4. 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:

  1. <UserControl x:Class=”LectorRSS.MainPage”
  2.     xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
  3.     xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
  4.     xmlns:d=”http://schemas.microsoft.com/expression/blend/2008″
  5.     xmlns:mc=”http://schemas.openxmlformats.org/markup-compatibility/2006″
  6.     mc:Ignorable=”d”
  7.     d:DesignHeight=”300″ d:DesignWidth=”400″>
  8.  
  9.     <Grid x:Name=”LayoutRoot”>
  10.         <Grid.Background>
  11.             <LinearGradientBrush EndPoint=”0.5,1″ StartPoint=”0.5,0″>
  12.                 <GradientStop Color=”Black” Offset=”0″/>
  13.                 <GradientStop Color=”#FFBBB9B9″ Offset=”0.943″/>
  14.             </LinearGradientBrush>
  15.         </Grid.Background>
  16.         <ItemsControl x:Name=”RSS” ItemsSource=”{Binding} Margin=”163,62,150,113″ >
  17.             <ItemsControl.ItemTemplate>
  18.                 <DataTemplate>
  19.                     <HyperlinkButton x:Name=”Title” NavigateUri=”{Binding RSSLink}
  20.              Width=”305″ Margin=”0,22,0,15″ Foreground=”#FFD5C214″
  21.              FontSize=”12″ FontWeight=”Bold”>
  22.                         <!–cada una de las entradas de RSS son introducidas en un hyperlink–>
  23.                         <TextBlock Text=”{Binding RSSTitle} TextWrapping=”Wrap” FontSize=”18.667″ FontFamily=”Times New Roman” Foreground=”#FF0CB8DC” />
  24.                         <!–cada uno de los hyperlinks mostrará el txto de cada una de las entradas–>
  25.                     </HyperlinkButton>
  26.  
  27.                 </DataTemplate>
  28.             </ItemsControl.ItemTemplate>
  29.         </ItemsControl>
  30.     </Grid>
  31. </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:

  1. private void client_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
  2.         {
  3.             if (e.Error == null)
  4.             {
  5.                 int itemsCount = 5;//número de entradas del RSS
  6.                 LectorXML = XmlReader.Create(new StringReader(e.Result));//lector de XML
  7.                 Feed = SyndicationFeed.Load(LectorXML); //se introduce el XML en una variable
  8.                 //de tipo SyndicationFeed
  9.  
  10.                 List<ElementosRSS> itemsList = new List<ElementosRSS>();//creamos una colección
  11.                 //para introducir los 5 elementos del RSS
  12.  
  13.                 if (Feed.Items.Count() < 5)
  14.                 {
  15.                     itemsCount = Feed.Items.Count();
  16.                 }
  17.  
  18.                 for (int i = 0; i <= itemsCount; i++)
  19.                 {
  20.                     ElementosRSS rssitem = new ElementosRSS();
  21.                     rssitem.RSSTitulo = Feed.Items.ToList()[i].Title.Text;
  22.                     rssitem.RSSEnlace = Feed.Items.ToList()[i].Links[0].Uri;
  23.                     //introducimos cada una de las propiedades en cada uno de los items de la colección de objetos
  24.                 }
  25.                 RSS.ItemsSource = itemsList;
  26.             }
  27.         }

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

 

  1. 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:

image

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:

image

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.