La Liga SilverlightSilverlight 4 | La Liga Silverlight

Utilizando un escáner desde una aplicación Silverlight

Rodrigo Díaz Concha — Wed, 03 Aug 2011 15:17:53 +0000

Como he mencionado anteriormente aquí y aquí, las aplicaciones de Silverlight pueden ser clientes de automatización, es decir, pueden invocar los servidores de automatización registrados en el sistema operativo Windows de la máquina del usuario.

Un requerimiento bastante común en aplicaciones de negocio es poder utilizar el escáner conectado desde nuestro aplicativo, para poder digitalizar una imagen y posteriormente serializarla a disco y/o presentarla en pantalla, etc.

En sistema operativo Windows contamos con WIA (Windows Image Acquisition), la cual es una plataforma que permite a nuestras aplicaciones interactuar con hardware de imágenes y también estandariza la interacción entre las aplicaciones y los escáneres, es decir, es un común denominador entre el manufacturero del dispositivo y tú como desarrollador. WIA está presente en Windows desde Windows ME en adelante, y su versión más reciente es la 2.0.

Es importante notar que tu hardware debe ser compatible con WIA para que el código de ejemplo de este artículo funcione. Revisa la documentación de tu escáner para conocer si existe compatibilidad.

WIA.CommonDialog

El objeto WIA.CommonDialog tiene diferentes métodos que nos ayudan a desplegar las cajas de diálogo para poder seleccionar un dispositivo de imagen, como una cámara o un escáner, y además para escanear una imagen. Si creamos una referencia a este objeto por medio de la clase AutomationFactory, podemos fácilmente integrar capacidades de escaneo en nuestra aplicación de Silverlight.

El objeto WIA.CommonDialog tiene algunos métodos bastantes interesantes, los cuales se destacan en la siguiente tabla:

ShowSelectDevice	Muestra una caja de diálogo para seleccionar el dispositivo que deseamos utilizar, por ejemplo una cámara o un escáner.
ShowDeviceProperties	Muestra las propiedades del dispositivo seleccionado en el método ShowSelectDevice
ShowAcquireImage	Abre una caja de diálogo para escanear una imagen, usando el dispositivo configurado por default

Puedes leer el artículo completo aquí

Herramientas de desarrollo para Windows Phone 7.1 Beta

Rodrigo Díaz Concha — Tue, 24 May 2011 18:00:47 +0000

El día de hoy se han liberado las Herramientas de desarrollo para Windows Phone 7.1 Beta o mejor conocido por su nombre clave “Mango”

Las pueden descargar directamente desde este vínculo.

Windows Phone 7.1 es un salto enorme para este sistema operativo ya que incluye cientos de características faltantes en la primera versión como por ejemplo multitasking, sockets, base de datos SQL local, acceso completo a los sensores, entre otros.

Si quieren conocer una lista más completa de las características presentes en esta nueva versión les sugiero ampliamente que revisen estos vínculos:

Qué hay de nuevo en las herramientas de desarrollo para Windows Phone
Qué hay de nuevo en Silverlight para Windows Phone
Herramientas para Mango disponibles hoy (Windows Phone Developer Blog)

¿Qué esperan? Bájenlas mientras están calientitas!

Salu2!

Tutorial Silverlight 4 – Extiende la galería de imágnes con LinqToXml

Héctor Hernández — Tue, 01 Mar 2011 22:32:36 +0000

En este video tutorial extiendo la Galería de Imágenes simple que mostré en el tutorial de aquí para agregarle la funcionalidad de descargar un archivo xml con la definición de una galería. Una vez descargado el archivo xml hacemos un ‘parsing’ simple con LinqToXml para cargar la información que compone la librería.

Los temas vistos en el video son:

Descarga de un archivo xml desde el server hasta el cliente a través de WebClient.
‘Parsing’ del archivo a través de LinqToXml.
Asignar objetos como DataContext de Controles desde Code-Behind.

Para ver el video tutorial ve a alFador en punto NET

Taller de Silverlight 4–Sesión 8

Rodrigo Díaz Concha — Wed, 16 Feb 2011 19:28:23 +0000

Después de varios siglos, el próximo día 22 de Febrero 2011 a las 19:00 horas (hora de México, Guadalajara, Monterrey) tendremos la Sesión 8 del Taller de Silverlight 4 Back to Basics. Esta sesión será llevada a cabo por mi buen amigo y colega Jorge Levy: Administrador y Autor en La Liga Silverlight. Les sugiero lo marquen en sus calendarios ya que Jorge estará completando los temas de acceso a datos específicamente con WCF RIA Services. Esta Sesión 8 cerrará (por fin ) este Taller de Silverlight 4.

Asimismo les recuerdo que todas las sesiones anteriores, las diapositivas usadas y los ejemplos de código están disponibles para su descarga aquí.

El vínculo para entrar ese día es este.

Los invito cordialmente a que asistan, preparen sus preguntas y participen en este evento!

Los esperamos!

Tutorial Silverlight 4 – Proyecto MVVM con Ria Services multi capa

Héctor Hernández — Wed, 09 Feb 2011 14:52:06 +0000

De vuelta con nuestros tutoriales semanales de Silverlight 4.

He navegado muchos sitios y foros de desarrolladores Silverlight buscando la respuesta a la pregunta: ¿Es posible crear un proyecto RIA Services con más de dos capas? Hace unos meses me encontré con un sitio donde mostraban una metodología para lograrlo. La verdad es que hoy en día (y gracias a mi descuido) he perdido la referencia a ese sitio. Sin embargo, el conocimiento quedó conmigo ya que lo uso contínuamente en diferentes proyectos Silverlight que desarrollo. Para mí, es momento de compartir de nuevo este conocimiento como me ha sido compartido y aprovecho para agregarle el toque MVVM.

¿De qué me serviría crear un sitio RIA Services con más de dos capas? Bien, la respuesta depende de la necesidad de cada proyecto. Yo en mi caso lo uso más o menos así:
Solución VS 2010
1. Proyecto Web con el Domain Service, Modelo y Conexión BD
2. Proyecto Librería Silverlight que será quien esté conectado a los RIA Services del Proyecto Web
3. N Proyectos Ejecutables de Silverilght que consumen los datos a través de los RIA Services que provee el Proyecto Librería

Ahora bien, yo en mi caso lo uso así, pero si tu tienes una aplicación Silverlight dividida en módulos es razonable querer tener acceso a los datos a través de todos los módulos de tu aplicación estén o no en el mismo .xap. Tener una librería Silverlight externa con conexión a RIA Services te permite separar este caso en un .xap independiente y consumir estos datos desde cualquier otra librería .xap o ejecutable Silverlight.

Después de esta introducción los dejo con el video tutorial en el que te explico como hacer este procedimiento. Te pido disculpas con anticipación pro la calidad del audio del video. Estoy trabajando en mejorar mis condiciones de grabación.

Los temas cubiertos en el video son:

Partiremos de una solución VS 2010 vacía.
Crearemos una aplicación web con un modelo, conexión a base de datos y servicios RIA.
Crearemos una librería Silverlight que consumirá los RIA Services
Terminaremos con un proyecto ejecutable de Silverlight con MVVM que servirá como cliente.

Para ver el video y bajar el código de ejemplo ve a alFador en punto net

Reunión de la Comunidad .NET Guatemala (08 de Febrero 2011)

Rodrigo Díaz Concha — Thu, 03 Feb 2011 16:26:15 +0000

Les invito cordialmente a todos(as) que asistan a la próxima reunión de la Comunidad de Desarrolladores .NET de Guatemala en donde tengo el honor de haber sido invitado como orador.

La cita es el próximo martes 08 de Febrero 2011, los datos completos a continuación:

Fecha: Martes 8 de Febrero de 2011
Hora: De 6:30pm a 8:30pm
Lugar Oficinas de Microsoft de Guatemala
Dirección: 14 calle 2-51 zona 10, Edificio Intercontinental Nivel 11 Oficina 1101
Precio: ¡¡Gratis!!
Habrá premios por participación

En esta sesión hablaremos de Silverlight 4. Si tienen dudas acerca de esta plataforma de desarrollo, o acerca de Windows Phone 7 por favor traiganlas para ayudarles a resolverlas!

Toda la información completa y el registro lo pueden encontrar aquí.

Allá nos vemos!!! Será un verdadero gusto conocerles.

Salu2!

Tutorial Silverlight 4 – Instalación del Framework MVVM Light

Héctor Hernández — Tue, 01 Feb 2011 16:12:27 +0000

Bienvenido de nuevo.

En este video tutorial te explicaré paso a paso el proceso de instalación del Framework MVVM Light. Éste Framework es desarrollado por Laurent Bugnion en Suiza y está enfocado en permitir de un modo simple el desarrollo de aplicación WPF y Silverlight (incluído WP7). El principal enfoque que tiene éste Framework es el de ser amigable con Expression Blend por lo que te permite desarrollar aplicaciones a través de la interfaz gráfica de Blend.

Los temas cubiertos en el video son:

Presentación corta del Framework MVVM.
Donde encontrar recursos, documentación y los archivos de instalación.
Guía paso a paso de la instalación en Visual Studio 2010 y Expression Blend.
Creación de un proyecto MVVM Light para probar la instalación del Framework

PARA VER EL VIDEO TUTORIAL VE A: alFador en punto NET

Cómo obtener la dirección IP local desde una aplicación de Silverlight

Rodrigo Díaz Concha — Fri, 07 Jan 2011 19:10:36 +0000

Introducción

Existen una gran cantidad de escenarios en donde es necesario conocer la dirección IP local de la máquina en donde está corriendo una aplicación, principalmente por cuestiones de auditoría, seguridad, etc. A partir de Silverlight 4 contamos con la posibilidad de ejecutar las aplicaciones Afuera del Navegador en un modelo de seguridad de Confianza Elevada, es decir, rebasando las restricciones inherentes a esta tecnología Web para que los aplicativos puedan comportarse casi como si se tratasen de una aplicación de escritorio tradicional.

En el caso de aplicaciones de Silverlight tradicionales (dentro del navegador) podríamos conocer la dirección IP del usuario en el Servidor. Pero ¿qué pasa con Aplicaciones Fuera del Navegador, en donde no tenemos la seguridad de que se cuente con acceso a un Servidor y mucho menos conectividad como tal?

En este artículo veremos cómo podemos obtener la dirección IP local del equipo desde una aplicación de Silverlight 4 que esté ejecutando en Confianza Elevada, a través del uso de WMI (acrónimo de Windows Management Instrumentation): la infraestructura de administración de datos (de hardware y software) y notificaciones en los Sistemas Operativos Windows.

Lee el artículo completo aquí

Como hacer una galería de imágenes con Silverlight 4

Héctor Hernández — Sun, 24 Oct 2010 18:54:46 +0000

En este video tutorial te explicaré como hacer una galería de imágenes con Silverilght 4 desde Blend 4 de una manera sencilla y rápida. Te demostraré como gracias al gran poder del ‘DataBinding’ de Silverlight y a al uso de ‘Behaviors’ y ‘Templating’, hacer una galería no es tan complicado como lo parece ya que no es necesario utilizar el ‘Code Behind’ para manejar eventos y posicionar elementos en pantalla.

Los temas vistos en el video son:

Posicionamiento de controles en el área de trabajo.
Mostrar datos dinámicos a través de DataBinding.
Como mejorar la visualización de estos elementos a través de ‘Templates’.
Usar ‘Behaviors’ para animar los elementos mostrados.

PARA VER EL VIDEO TUTORIAL VE A alFador en punto net.

Descarga el código fuente de ejemplo: Galeria Simple de Imágenes en Silverlight 4

Creación y utilización de un servicio WCF en Windows Phone 7

raul.mayo — Mon, 20 Sep 2010 12:49:53 +0000

En estos últimos días en los que estado probando las distintas formas de obtener datos desde una fuente (Web Services,WPF, REST, etc..), he creado un servicio de WCF que más tarde he usado en Windows Phone 7.

En este post voy a elaborar un servicio sencillo, en el que el usuario introduzca un nombre en la interfaz de WP7 esta petición es pasada al servicio que obtiene los detalles del contacto(Nombre, Apellido, teléfono,etc..) desde una base de datos (que crearemos para dicho fin). Por últimos estos detalles del contacto, son presentados en la interfaz de usuario de WP7.

Comenzaremos creando una nueva base de datos, para ello utilizaremos en SQL Server Management Studio en mi caso la versión 2008. Realizamos clic con el botón derecho sobre Bases de Datos y seleccionamos la opción Nueva Base de Datos.

Introducimos el nombre de la base de datos,en mi caso Contactos. Expandimos la tabla recientemente creada y hacemos clic con el botón derecho sobre Tablas, seleccionando Nueva Tabla.

Ahora vamos a diseñar los campos de la tabla que tendrán las siguientes características:

IDContacto: nchar(10) clave primeria

Nombre:nchar(50)

Apellidos:nchar(50)

Teléfono:numeric(18, 0) permitir valores nulos

Email:nchar(50) permitir valores nulos

También nombraremos la tabla como DTContactos y rellenamos la tabla con los respectivos datos de los contactos.

El siguiente paso es la creación del servicio WCF. Para ello abrimos Visual Studio 2010, seleccionamos Archivo->Nuevo Proyecto. En el área de plantillas seleccionamos WCF y elegimos la plantilla WCF Service Application. Introducimos el nombre y la ubicación del servicio como podemos observar a continuación:

Ahora vamos añadir un nuevo elemento que nos va permitir obtener los datos desde la base de datos a través de una clase LINQ. Para ello con el botón derecho sobre el servicio(WcfService) , seleccionamos Añadir->Nuevo elemento. En la ventana emergente seleccionamos la plantilla LINQ to SQL Clasess contenida en la sección Data.

Ahora nos situamos en el explorador del servidor de Visual Studio 2010. Si no consiguiéramos ver dicho elemento lo añadiríamos desde el menú Vista->Server Explorer. Desplegamos el explorador del servidor sobre Data Connections presionamos con el botón derecho para seleccionar Añadir Conexión.

Al realizar esta acción nos encontraremos con una ventana emergente, donde podremos seleccionar la ubicación de la base de datos creada con anterioridad.

Ahora desplegamos la base de datos Contactos->Tablas y arrastramos la tabla DTContacto encima de la clase de LINQ agregada en el anterior paso.

Ahora accedemos a IService1.cs y dejamos dicho elemento del siguiente modo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
namespace WcfService
{
[ServiceContract]
public interface IService1
{
[OperationContract]
List<DTContacto> EncontrarContacto(string NombreCT);
}
}

Como podemos observar la Interfaz Iservice1 es el contrato de servicio de WCF en el que hemos declarado una única función que toma una cadena como argumento (Nombre del contacto) y devuelve una lista de tipo DTContacto que es la clase de nuestro modelo de datos.

Ahora accedemos a Service1.svc.cs y dejamos dicho elemento del siguiente modo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.ServiceModel.Web;
using System.Text;
namespace WcfService
{
// NOTE: You can use the “Rename” command on the “Refactor” menu to change the class name “Service1″ in code, svc and config file together.
public class Service1 : IService1
{
public List<DTContacto> EncontrarContacto(string NombreCT)
{
DataClasses1DataContext context = new DataClasses1DataContext();
var res = from r in context.DTContactos where r.Nombre == NombreCT select r;
return res.ToList();
}
}
}

La clase Service1.svc.cs es el servicio encargado de implementar el contrato de servicio IService1. Dentro de dicha clase hemos definido el método EncontrarContacto. Dentro de este, hemos creado un objeto de contexto de datos, Además de una consulta LINQ que obtiene los datos de la base de datos en función del nombre introducido por el usuario. De este modo nos devuelve una lista de objeto de tipo DTContactos.

Seguidamente nos situamos sobre el servicio Service1.svc con el botón derecho elegimos Ver en el Buscador. De esta forma podremos comprobar el correcto funcionamiento del servicio en el explorador.

Copiaremos la URL del Servicio para utilizarla a la hora de añadir el servicio en Windows Phone 7. El siguiente paso es la creación de una nueva aplicación Windows Phone 7. Para ello en visual estudio elegimos la plantilla Windows Phone Application dentro del área Silverlight For Windows Phone.

Comenzamos introduciendo la interfaz de usuario de WP7. Para ello introducimos el siguiente código en MainPage.xaml :

<phone:PhoneApplicationPage
x:Class=”WindowsPhoneApplication.MainPage”
xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
xmlns:phone=”clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone”
xmlns:shell=”clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone”
xmlns:d=”http://schemas.microsoft.com/expression/blend/2008″
xmlns:mc=”http://schemas.openxmlformats.org/markup-compatibility/2006″
FontFamily=”{StaticResource PhoneFontFamilyNormal}“
FontSize=”{StaticResource PhoneFontSizeNormal}“
Foreground=”{StaticResource PhoneForegroundBrush}“
SupportedOrientations=”Portrait” Orientation=”Portrait”
mc:Ignorable=”d” d:DesignWidth=”480″ d:DesignHeight=”768″
shell:SystemTray.IsVisible=”True”>
<Grid x:Name=”LayoutRoot” Background=”Transparent”>
<Grid.RowDefinitions>
<RowDefinition Height=”Auto”/>
<RowDefinition Height=”*”/>
Grid.RowDefinitions>
<StackPanel x:Name=”TitlePanel” Grid.Row=”0″ Margin=”24,24,0,12″>
<TextBlock x:Name=”PageTitle” Text=”CONTACTOS” Margin=”-3,-8,0,0″ Style=”{StaticResource PhoneTextTitle1Style}“/>
StackPanel>
<Grid x:Name=”ContentGrid” Grid.Row=”1″>
<TextBox Height=”79″ HorizontalAlignment=”Left” Margin=”51,218,0,0″ Name=”textBox1″ Text=”" VerticalAlignment=”Top” Width=”401″ />
<Button Height=”70″ HorizontalAlignment=”Left” Margin=”152,304,0,0″ Name=”button1″ VerticalAlignment=”Top” Width=”160″ Content=”BUSCAR” Click=”button1_Click” />
<TextBlock Height=”57″ HorizontalAlignment=”Left” Margin=”63,122,0,0″ Name=”textBlock1″ Text=”INTRODUZCA EL NOMBRE DEL CONTACTO A BUSCAR:” VerticalAlignment=”Top” Width=”398″ FontFamily=”Segoe WP Black” TextWrapping=”Wrap” />
Grid>
Grid>
phone:PhoneApplicationPage>

El siguiente paso añadir el servicio al proyecto WP7. Para ello hacemos clic sobre Referencias y seleccionamos Añadir Referencia de Servicio. En la ventana emergente, en el apartado Address introducimos la dirección del servicio que hemos copiado con anterioridad. Presionamos el botón GO para comprobar que se conecta correctamente al servicio. En último lugar nombraremos el espacio de nombres del servicio como ServiceReference como podemos observar a continuación:

Ahora vamos añadir una nueva página en el proyecto que mostrará los diferentes detalles del contacto una vez devuelta la petición a la base de datos. Presionamos con el botón derecho sobre el Proyecto(WindowsPhoneApplication), seleccionamos Añadir->Nuevo Elemeto. Seleccionamos la plantilla Windows Phone Portrait Page como podemos observar en la imagen:

Dentro de la interfaz de usuario vamos a incluir un control Listbox, dentro del mismo crearemos una plantilla para incluir los diferentes objetos Texblock que enlazarán con las propiedades del elemento buscado, recuperado de la base de datos. Este es el resultado de la interfaz de usuario de Page1.xaml:

<phone:PhoneApplicationPage
x:Class=”WindowsPhoneApplication.Page1″
xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
xmlns:phone=”clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone”
xmlns:shell=”clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone”
xmlns:d=”http://schemas.microsoft.com/expression/blend/2008″
xmlns:mc=”http://schemas.openxmlformats.org/markup-compatibility/2006″
FontFamily=”{StaticResource PhoneFontFamilyNormal}“
FontSize=”{StaticResource PhoneFontSizeNormal}“
Foreground=”{StaticResource PhoneForegroundBrush}“
SupportedOrientations=”Portrait” Orientation=”Portrait”
mc:Ignorable=”d” d:DesignHeight=”768″ d:DesignWidth=”480″
shell:SystemTray.IsVisible=”True”>
<phone:PhoneApplicationPage.Resources>
<Style x:Key=”ListBoxItemStyle1″ TargetType=”ListBoxItem”>
<Setter Property=”Template”>
<Setter.Value>
<ControlTemplate TargetType=”ListBoxItem”>
<Grid/>
ControlTemplate>
Setter.Value>
Setter>
Style>
<ControlTemplate x:Key=”ListBoxControlTemplate1″ TargetType=”ListBox”>
<Grid/>
ControlTemplate>
phone:PhoneApplicationPage.Resources>
<Grid x:Name=”LayoutRoot” Background=”Transparent”>
<Grid.RowDefinitions>
<RowDefinition Height=”Auto”/>
<RowDefinition Height=”*”/>
Grid.RowDefinitions>
<StackPanel x:Name=”TitlePanel” Grid.Row=”0″ Margin=”24,24,0,12″>
<TextBlock x:Name=”PageTitle” Text=”Detalles Contacto” Margin=”-3,-8,0,0″ Style=”{StaticResource PhoneTextTitle1Style}“ FontSize=”56″ />
StackPanel>
<Grid x:Name=”ContentGrid” Grid.Row=”1″>
<ListBox Height=”503″ HorizontalAlignment=”Left” Margin=”20,22,0,0″ Name=”listBox1″ VerticalAlignment=”Top” Width=”434″ >
<ListBox.ItemTemplate>
<DataTemplate>
<StackPanel Orientation=”Vertical”>
<TextBlock Text=”Nombre:” Foreground=”#FFFB0000″ FontSize=”29.333″/>
<TextBlock Text=”{Binding Nombre}“ FontSize=”29.333″/>
<TextBlock Text=”Apellidos:” FontSize=”29.333″ Foreground=”#FFFD0000″/>
<TextBlock Text=”{Binding Apellidos}“ FontSize=”29.333″/>
<TextBlock Text=”Teléfono” FontSize=”29.333″ Foreground=”#FFFE0000″/>
<TextBlock Text=”{Binding Teléfono}“ FontSize=”29.333″/>
<TextBlock Text=”Email:” FontSize=”29.333″ Foreground=”Red” />
<TextBlock Text=”{Binding Email}“ FontSize=”29.333″/>
StackPanel>
DataTemplate>
ListBox.ItemTemplate>
ListBox>
Grid>
Grid>
phone:PhoneApplicationPage>

Seguidamente nos situamos en el evento clic del botón de busqueda, dentro de MainPage.Xaml.cs e introducimos código necesario para enviar a Page1 la cadena que el usuario ha introducido en el control habilitado para tal fin:

private void button1_Click(object sender, RoutedEventArgs e)
{
string s = textBox1.Text;
this.Content = new Page1(s);
}

El siguiente paso es situarnos en Page1.Xaml.cs referenciando el servicio en dicho archivo:

using WindowsPhoneApplication.ServiceReference;

Ahora realizaremos la llamada asincrona al servicio( forma normal de realizar la llamada en Silverlight), para recuperar el dato pedido, pasando al servicio el parámetro del contacto deseado. Una vez que se haya completado la llamada asincrona, el dato del contacto será devuelto e introducido en la interfaz del usuario a través del ListBox.

namespace WindowsPhoneApplication
{
public partial class Page1 : PhoneApplicationPage
{
public Page1(string s)
{
InitializeComponent();
Service1Client proxy = new Service1Client();
proxy.EncontrarContactoCompleted += new EventHandler<EncontrarContactoCompletedEventArgs>(proxy_EncontrarContactoCompleted);
//controlado del evento de completar la llamada al servicio
proxy.EncontrarContactoAsync(s);
//llamada al método del servicio de forma asincrona
}
void proxy_EncontrarContactoCompleted(object sender, EncontrarContactoCompletedEventArgs e)
{
listBox1.ItemsSource = e.Result;//carga datos del contacto en el ListBox
}
}
}

Llegados a este punto solo nos queda ejecutar el proyecto, introducir el nombre del contacto a buscar.

Obteniendo los detalles del contacto al Instante.

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

raul.mayo — Tue, 07 Sep 2010 12:23:40 +0000

Voy a empezar mi andadura en la Liga Silverlight, publicando un artículo que he publicado con anterioridad en mi blog. Pero que personalmente es de gran interés, debido a que podemos sacar lo mejor de dos plataformas punteras de Microsoft como son Silverlight y SharePoint 2010.

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="ModuloSilverlight\AplicacionSilverlight.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 Programa\Common Files\Microsoft Shared\Web Server Extensions\14\TEMPLATE\LAYOUTS\ClientBin .

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.

Espero que hayáis disfrutado de esta primera entrada y deseo que en un futuro sigáis leyendo las distintas publicaciones que realizaré.

Actualización de Silverlight 4

Arturo Molina — Fri, 03 Sep 2010 04:13:06 +0000

El día de ayer se liberó una actualización para Silverlight 4 (Versión 4.0.50826.0 para ser exactos). Este es un pequeño resumen de lo que incluye esta actualización:

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:

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

Anunciando: Taller de Silverlight 4

Rodrigo Díaz Concha — Tue, 24 Aug 2010 21:09:06 +0000

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!!!

Taller de Silverlight 4 gratuito

Arturo Molina — Fri, 13 Aug 2010 03:53:58 +0000

Mi querido amigo Rodrigo Díaz está planeando un taller gratuito de Silverlight 4. Por el momento, está en fase de planeación y está pidiendo ayuda de la comunidad para saber qué es lo que funciona mejor para la mayoría (horarios, modalidad, temas, etc…)

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.

Lanzamiento de Visual Studio .NET 2010 y Silverlight 4 @ Trujillo, Perú

Rodrigo Díaz Concha — Thu, 20 May 2010 14:42:38 +0000

Invitado por la Universidad Privada del Norte en Trujillo, Perú, estaré dando una charla allá el día sábado 22 de Mayo a las 09:00 horas acerca de Silvelight 4 y Windows Phone 7. Durante el evento también se hablará de Visual Studio .NET 2010 y sus nuevas características.

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!

Segunda parte del Curso Introductorio a Silverlight 4

Arturo Molina — Thu, 06 May 2010 04:03:21 +0000

Ya habiamos mencionado sobre el Curso Introductorio a Silverlight 4, hecho por Rodrigo Díaz y hospedado en Channel 9. Ya está actualizado el contenido de nuestra sección de Tutoriales, pero también pueden ver el anuncio de Rodrigo aquí.

Les recomiendo lo vean para que conozcan las nuevas características de Silverlight, antes de que salga la siguiente versión en… ¿Dos semanas? (Esperemos que no, pero uno nunca sabe).

Silverlight 4 – Creación de Temas

Rodrigo Díaz Concha — Mon, 19 Apr 2010 05:20:22 +0000

Como lo había mencionado en un artículo anterior, Silverlight 4 incluye soporte para Estilos Implícitos, los cuales son estilos que pueden aplicar a todos los elementos y/o controles de un mismo tipo, en vez de estar aplicando el estilo de manera explícita elemento por elemento o control por control.

Gracias a esta característica, podemos crear “Temas” para nuestros aplicativos sin la necesidad de utilizar componentes externos (como la clase ImplicitStyleManager, incluida en el Silverlight Toolkit). La idea detrás de este concepto es tener Diccionarios de Recursos de tipo Mezclados (Merged), que contengan toda la serie de estilos para los controles de la aplicación y posteriormente aplicar uno u otro Diccionario. En este artículo mostraré este concepto, para poder construir aplicaciones que incluyan diferentes temas para la Interface de Usuario.

La solución

Iniciaremos creando en Visual Studio .NET 2010 un nuevo proyecto de tipo Silverlight Application, aceptando las opciones predeterminadas. A este proyecto le pondremos Demo.SL4.Temas.

Diccionarios Mezclados

Los Diccionarios Mezclados (o Merged en inglés) permiten declarar recursos en archivos independientes, para posteriormente reutilizar estos archivos en alguna otra aplicación Silverlight o incluso de WPF. En nuestra aplicación de ejemplo crearemos dos diccionarios: Rojo.xaml y Azul.xaml. Cada uno de ellos tendrá los Estilos Implícitos convenientes para cada tema (tonalidades rojizas en Rojo.xaml y azules en Azul.xaml). Podemos hacer esto por medio de Visual Studio .NET 2010 o con Expression Blend 4; pero con este último tenemos más control así que utilizaremos dicha herramienta. Para abrir Expression Blend 4 directamente desde Visual Studio .NET 2010 hagamos clic-derecho sobre el archivo MainPage.xaml y seleccionemos la opción “Open in Expression Blend…”:

Puedes leer el artículo completo aquí

RIA Services en práctica Parte I – Personalizando el diseño

Arturo Molina — Fri, 08 Jan 2010 16:47:08 +0000

Leer artículo completo aquí.
WCF RIA Services es una excelente herramienta que podemos utilizar en Silverlight para manejar nuestro acceso a datos. Si aún no te has introducido en el tema, te recomiendo echar un vistazo a la serie de posts sobre RIA Services de Jorge Levy sobre el tema.

Esta serie de posts pretende ser un poco menos introductoria y más enfocada a hacer una aplicación real, pero sencilla.

Vamos a realizar una aplicación para ayudar en un intercambio de regalos (si, este post llega un poco tarde, pero por lo menos espero que sea ilustrativo).

Nuestro objetivo en este post será hacer una aplicación como esta:

Puedes leer el artículo completo aquí.