Tip Rápido: Obtener Valor Identity Disponible

Definición del Problema

Dada una tabla de Base de datos con un campo auto numérico, es decir, Identity en Sql Server, el valor no se puede repetir a no ser que eliminemos el registro, y forcemos a que se reinicie en un momento dado, y luego ….

El problema que quiero definir es como obtener los saltos existentes, es decir, aquellos que han sido borrados.

Solución

Como LINQ es algo que me encanta voy a proponer una solución utilizando LINQ:

 

Imaginemos un conjunto de registros cuyo campo Identity presenta estos valores: 1,2,3,5,6,7,9,10,11,15.

 

Para simplificar el ejemplo, voy a definir los en una lista:

   1: List<int> listado = new List<int>();

   2: listado.AddRange(new []{1,2,3,5,6,7,9,11,15});

En principio vamos a realizar una consulta sobre la lista/array/EntitySet… como la siguiente:

 

   1: var query = from n in listado

   2:             where (n!=1 && (!listado.Contains(n-1)))

   3:             select listado.IndexOf(n);

Con esto vamos a obtener los saltos existentes: 5,9,11,15

Al ir a realizar una inserción nos bastaría con obtener el primero de ellos, por lo tanto usaremos el siguiente fragmento:

   1: int numero = query.FirstOrDefault() + 1;

Espero que os sirva.

 

Saludos

Edit: Después del comentario de Santiago, he pensado una solución más rápida digamos. En principio, las posiciones de cada elemento de la lista deben corresponder con el valor de su indice – 1, si no es así significaría que tenemos un salto:

 

 

   1: var query = from n in listado

   2:               where (n > 1 && (listado.IndexOf(n)!=n-1))

   3:               select listado.IndexOf(n);

[XAML] Estilos

Definición

Podríamos definir estilo como el aspecto visual que va a tener un elemento dentro de nuestra Interfaz de Usuario.

Será un fragmento de XAML que podremos establecer de alguna de las siguientes maneras:

Formas de Establecer Estilos y Plantillas

=> Modificando las propiedades: La forma “tradicional” de cambiar el aspecto sería modificando las propiedades directamente desde el XAML, o la ventana de propiedades para aquellas donde es factible hacerlo.

Ejemplo:

   1: <Button Name="boton" Margin="188,127,191,166">

   2:     <Button.Background>

   3:         <SolidColorBrush Opacity="0.7" Color="Green"></SolidColorBrush>

   4:     </Button.Background>

   5:  </Button>

=> Agregando un aparatado de recursos a nuestra ventana / UserControl:

   1: <Window.Resources>

   2:    <Style x:Key="botoncito" TargetType="Button">

   3:         <Setter Property="Background">

   4:             <Setter.Value>

   5:                 <SolidColorBrush Opacity="0.7" Color="Green"></SolidColorBrush>

   6:             </Setter.Value>

   7:         </Setter>

   8:     </Style>

   9: </Window.Resources>

  10:     <Grid>

  11:         <Button Name="boton" Margin="188,127,191,166" Style=”{StaticResource botoncito}”/>

  12:     </Grid>

De esta manera lograremos que todos los botones dentro de esta ventana tengan el mismo estilo, a no ser que indiquemos lo contrario con:

   1: <Button Name="boton2" Margin="188,240,191,53" Style="{x:Null}"/>

O Indiquemos otro estilo concreto:

   1: <Button Name="boton3" Margin="188,240,191,53" Style="{StaticResource botoncito2}"/>

=>Agregando nuestros estilos al fichero App.xaml dentro del Apartado Application.Resources:

   1: <Application.Resources>

   2:     <Style x:Key="botoncito" TargetType="Button">

   3:         <Setter Property="Background">

   4:             <Setter.Value>

   5:                 <SolidColorBrush Opacity="0.7" Color="Green"></SolidColorBrush>

   6:             </Setter.Value>

   7:         </Setter>

   8:     </Style>

   9: </Application.Resources>

De esta forma los estilos estarán disponibles para ser utilizados desde todas las partes de la aplicación.

=> Agregando un fichero de Recursos: Creo que la mejor forma de trabajar con estilos es definir una fichero de Recursos desde la solución de VS, agregando un fichero del tipo “Resources Dictionary”, donde definiremos nuestros estilos:

   1: <ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

   2:                     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

   3:         <Style x:Key="botoncito" TargetType="Button">

   4:             <Setter Property="Background">

   5:                 <Setter.Value>

   6:                     <SolidColorBrush Opacity="0.7" Color="Green"></SolidColorBrush>

   7:                 </Setter.Value>

   8:             </Setter>

   9:         </Style>

  10: </ResourceDictionary>

Y para que podamos utilizarlos en toda la aplicación, dentro del fichero App.xaml,en el apartado de recursos indicaremos la siguiente línea:

   1: <Application.Resources>

   2:     <ResourceDictionary Source="Dictionary1.xaml"/>

   3: </Application.Resources>

Información Útil de los Estilos

A la hora de definir un estilo es necesario que indiquemos algunas cosas:

– TargetType: es el control tipo cuyo estilo queremos personalizar. Al establecer, cuando vayamos a definir los estilos, podremos tener ayuda para ver que propiedades se pueden establecer.

– Name / Key:  El nombre o la clave nos va a permitir identificar los estilos que estamos aplicando. Si establecemos la propiedad “Name”, todos los controles del tipo indicado, establecerá su estilo al definido, a no ser que indiquemos lo contrario. En cambio, si utilizamos “Key”, será necesario establecer la propiedad Style asignándola a un recursos estático a través de Binding.

 

Espero que os sea de utilidad.

 

Saludos!

[XAML] Plantillas

Introducción

Cuando en las aplicaciones de escritorio desarrolladas con Windows Forms, queríamos modificar el aspecto de un determinado control, teníamos bastantes limitaciones de las cosas que podíamos hacer con ellos, a no ser que modificásemos internamente desde código su apariencia.

Tanto en WPF como en Silverlight, podemos modificar la apariencia de los controles de varías maneras.

En este post vamos a ver como modificar un control a través de las Plantillas.

 

Definición y Tipos

Una plantilla va a permitir definir la forma de visualización de un control modificando el árbol visual del mismo.

=> ControlTemplate

El tipo ControlTemplate se utiliza para definir la estructura visual de un control.

Ejemplo:

   1: <Button Margin="0,0,213,247" Click="Button_Click" Content="Prueba">

   2:     <Button.Template>

   3:         <ControlTemplate>

   4:             <Grid>

   5:                 <Ellipse Fill="Red"/>

   6:                 <ContentPresenter Content="{TemplateBinding Content}"/>

   7:             </Grid>

   8:         </ControlTemplate>

   9:     </Button.Template>

  10: </Button>

=> DataTemplate

El tipo DataTemplate se utilizara para definir la estructura visual de un elemento dentro de un control que muestra datos, como puede ser un ListBox.

Ejemplo:

   1: <ListBox x:Name="Listado" Margin="0,0,31,22" ItemsSource="{Binding Evaluaciones}">

   2:             <ListBox.ItemTemplate>

   3:                 <DataTemplate>

   4:                     <Grid>

   5:                         <Expander Header="{Binding Cabecera}">

   6:                             <ListBox ItemsSource="{Binding Listado}">

   7:                                 <ListBox.ItemTemplate>

   8:                                     <DataTemplate>

   9:                                         <Grid>

  10:                                             <Label Content="{Binding Campo2}"/>

  11:                                             <Label Content="{Binding Campo3}"/>

  12:  

  13:                                         </Grid>

  14:                                     </DataTemplate>

  15:                                 </ListBox.ItemTemplate>

  16:                             </ListBox>

  17:                         </Expander>

  18:                     </Grid>

  19:                 </DataTemplate>

  20:             </ListBox.ItemTemplate>

  21:         </ListBox>

 

En el próximo post hablaré de los Estilos y comentaré las distintas formas de definir las Plantillas.

Espero que os sea de utilidad.

Saludos.

[WPF]Triggers

Definición

Un Trigger es un desencadenador de una determinada Acción.

Va a permitir cambiar el valor de alguna propiedad o comenzar una animación existente, cuando se cumpla una determinada condición.

Tipos

Existen distintos tipos de Triggers:

=> Trigger simple: Sucede cuando una determinada Propiedad presenta un valor indicado. Ejemplo:

       1: <Triggers>

       2:     <Trigger Property="IsSelected" Value="True">

       3:         <Setter TargetName="desc" Property="Foreground" Value="Blue"/>

       4:     </Trigger>

       5: </Triggers>

La explicación sería: Cuando la propidad IsSelected (el ejemplo es para un Item de un ListBox) se establece a True, cambiaremos la propiedad Foreground al color Azul en el objeto “desc”.

Dentro del contenido del Trigger, podremos establecer tantos “Setters” como necesitemos.

Se pueden utilizar las propiedades EnterActions y ExitActions del Trigger, para definir el comportamiento al lanzarse el Trigger, y cuando vuelve al valor original.

=> EventTrigger: se desencadena cuando un evento sucede. Ejemplo:

 

   1: <Rectangle Fill="Red"  Height="176" HorizontalAlignment="Left" Margin="94,94,0,0" 

   2:    Name="rectangle1" Stroke="Black" VerticalAlignment="Top" Width="316">

   3:             <Rectangle.Triggers>

   4:                 <EventTrigger RoutedEvent="Rectangle.Loaded">

   5:                     <BeginStoryboard>

   6:                         <Storyboard>

   7:                             <DoubleAnimation

   8:                                     Storyboard.TargetName="rectangle1" 

   9:                                     Storyboard.TargetProperty="Opacity"

  10:                                     From="0.0" To="1.0" Duration="0:0:2" />

  11:                             <DoubleAnimation Storyboard.TargetName="rectangle1" 

  12:                                  Storyboard.TargetProperty="Width" BeginTime="0:0:2" 

  13:                                     From="316" To="400" Duration="0:0:3"/>

  14:                         </Storyboard>

  15:                         

  16:                     </BeginStoryboard>

  17:                 </EventTrigger>

  18:             </Rectangle.Triggers>

  19:             </Rectangle> 

La explicación sería: Cuando se produzca el evento Loaded del rectángulo, haremos que se haga visible de forma gradual, y lo moveremos a la derecha desde su posición inicial.

=> MultiTrigger: se desencadenan cuando un conjunto de condiciones se cumplen. Ejemplo:

   1: <ListBox >

   2:             <ListBox.Style>

   3:                 <Style>

   4:                     <Style.Triggers>

   5:  

   6:  

   7:                     <MultiTrigger>

   8:                         <MultiTrigger.Conditions>

   9:                                 <Condition Property="ListBox.HasItems" Value="False" />

  10:                                 <Condition Property="ListBox.Width" Value="Auto" />

  11:                         </MultiTrigger.Conditions>

  12:                             <Setter Property="ListBox.Background" Value="Red"/>

  13:                     </MultiTrigger>

  14:  

  15:                  </Style.Triggers>

  16:                 </Style> 

  17:             </ListBox.Style>

  18:         </ListBox>

La explicación sería: Si las propiedades HasItems y Width tienen como valores False y Auto, respectivamente, el color de fondo del ListBox se establecerá a Rojo.

=> DataTrigger y MultiDataTrigger: se desencadenan cuando una o varias condiciones enlazadas a datos se cumplen.

   1: <DataTrigger Binding="{Binding Path=Nombre}" Value="Javier">

   2:        <Setter Property="Foreground" Value="Green" />

   3:      </DataTrigger>    

   1: <MultiDataTrigger>

   2:         <MultiDataTrigger.Conditions>

   3:           <Condition Binding="{Binding Path=Nombre}" Value="Javier" />

   4:           <Condition Binding="{Binding Path=Apellidos}" Value="Torrecilla Puertas" />

   5:         </MultiDataTrigger.Conditions>

   6:         <Setter Property="ForeGround" Value="DarkBlue" />

   7:       </MultiDataTrigger>

Conclusión

Los trigger, nos va a permitir de forma cómoda el cambio de ciertas propiedades directamente desde el código XAML, sin tener que escribir código C# o VB.

Espero que os sea de utilidad.

Fuentes: Trigger en MSDN

[SL]Empezando con SL, Datos y MVVM

Introducción

En el post anterior estuvimos viendo, una de las formas que tenemos, para consultar los datos de nuestra BD y explotarlos desde Silverlight.

El objeto de este POST, es empezar a adoptar el patrón de diseño MVVM.

MVVM

Hay muchos post abierto acerca del patrón MVVM(Model-View-ViewModel, pero os recomiendo que os leais el tercer capítulo del libro de WP7 de Josue Yeray (al igual que el primero y segundo).

Me gustaría indicar que este patrón aplica tanto a Silverlight (incluyendo WP7) como WPF.

Componentes de MVVM

Los componentes de MVVM son los siguientes:

Model: son los datos que se van a manejar.

View: Va a ser el control donde se va a visualizar la información aportada desde el ViewModel.

ViewModel: Es el encargado de relacionar la vista con el modelo.

En este patrón entra en juego el conocer el estado de los objetos, a través de la interfaz “INotifyPropertyChanged” de la cual ya hable hace un tiempo.

Dentro de MVVM tienen mucha importancia las propiedades y los comandos, que veremos en próximos posts.

Aplicando el patrón a Nuestro Proyecto

En el ejemplo del post anterior teniamos una estructura como la siguiente:

– Client.Aplicacion (Aplicación Silverlight)

– Client.Aplicacion.Web (Aplicación base para alojar la primera)

– Server.Datos (Proyecto con las clases del modelo de EF)

– Server.Servicios (Domain Services para comunicar con la BD)

Nuestro Domain Services va a actuar como “Model” dentro de MVVM.

Vamos a agregar dos nuevos proyectos a nuestra solución de Visual Studio:

  1. Proyecto del Tipo: Silverlight Class Library, al que llamaremos Client.ViewModels.
    Dentro de este proyecto vamos a agregar una nueva clase que va a servir de base para todas las ViewModels de nuestra aplicación.
       1: using System.ComponentModel;

       2:  

       3: namespace Client.ViewModels

       4: {

       5:     public class vmBase : INotifyPropertyChanged 

       6:     {

       7:  

       8:         public event PropertyChangedEventHandler PropertyChanged;

       9:         public void CambiarPropiedad(string propiedad)

      10:         {

      11:             if (PropertyChanged != null)

      12:                 PropertyChanged(this, new PropertyChangedEventArgs(propiedad));

      13:         }

      14:     }

      15: }

  2. Proyecto del Tipo: Silverlight Class Library, al que llamaremos Client.Views.

    Dentro de este proyecto vamos a alojar todas las vistas de la aplicación.

Al igual que en nuestro proyecto anterior vamos a mostrar por pantalla los datos relativos a las Categorias.

El primer paso será establecer en las propiedades del proyecto Client.ViewModels el enlace a WCF Ria Services link, que en este caso será “Server.Servicio”.

A continuación, vamos a crear un ViewModel que herede de la clase base que definimos anteriormente, para que tengamos como propiedades todas las características que queramos exponer. En el caso que nos atañe queremos tener un listado de las Categorías de nuestra BD

   1: using System.ServiceModel.DomainServices.Client;

   2:  

   3: namespace Client.ViewModels

   4: {

   5:     public class vmCategorias : vmBase 

   6:     {

   7:         Server.Servicio.dServicio context;

   8:         public vmCategorias()

   9:         {

  10:             context = new Server.Servicio.dServicio();

  11:             context.Load(context.GetCategoriesQuery());

  12:             Categorias = context.Categories;

  13:         }

  14:         private EntitySet<Server.Datos.Categories> _Categorias;

  15:         public EntitySet<Server.Datos.Categories> Categorias

  16:         {

  17:             get { 

  18:                 return _Categorias; 

  19:             }

  20:             set { 

  21:                 _Categorias = value;

  22:             CambiarPropiedad("Categorias");

  23:             }

  24:  

  25:         }

  26:     }

  27: }

Una vez definida la ViewModel que nos indicará los datos que vamos a visualizar, ahora vamos a definir como queremos visualizarlos a través de una Vista.

A continuación vamos a agregar la referencia del proyecto “ViewModels” al proyecto “Views”, para poder comunicarlos.

Para ello, vamos a agregar al proyecto “Client.Views” un nuevo UserControl, y vamos a definir su código XAML como:

   1: <UserControl x:Class="Client.Views.uCategorias"

   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:     <Grid x:Name="LayoutRoot" Background="White">

   9:         <ListBox x:Name="lCategorias" ItemsSource="{Binding Categorias}">

  10:             <ListBox.ItemTemplate>

  11:                 <DataTemplate>

  12:                     <Grid>

  13:                         <Grid.ColumnDefinitions>

  14:                             <ColumnDefinition/>

  15:                             <ColumnDefinition/>

  16:                         </Grid.ColumnDefinitions>

  17:                         <TextBlock Grid.Column="0" Text="{Binding CategoryName}"/>

  18:                         <TextBlock Grid.Column="1" Text="{Binding Description}"/>

  19:                     </Grid>

  20:                 </DataTemplate>

  21:             </ListBox.ItemTemplate>

  22:         </ListBox>

  23:     </Grid>

  24: </UserControl>

Y vamos a realizar el enlace con la ViewModel que definimos anteriormente desde el Code Behind:

   1: using System.Windows;

   2: using System.Windows.Controls;

   3: using System.ComponentModel;

   4:  

   5: namespace Client.Views

   6: {

   7:     public partial class uCategorias : UserControl

   8:     {

   9:         public uCategorias()

  10:         {

  11:             InitializeComponent();

  12:             this.Loaded += new RoutedEventHandler(uCategorias_Loaded);

  13:         }

  14:  

  15:         void uCategorias_Loaded(object sender, RoutedEventArgs e)

  16:         {

  17:             if (DesignerProperties.IsInDesignTool)

  18:                 return;

  19:             this.DataContext = new ViewModels.vmCategorias();

  20:         }

  21:     }

  22: }

Tal como comente en otro post anterior, para evitar un error realizo la comprobación de si estamos en diseño.

 

Una vez definida nuestros ViewModel y View, es el momento de que lo agregemos a nuestra Aplicación principal. Para ello, agregaremos la referencia al proyecto Client.Views (dentro del proyecto principal) y estableceremos el siguiente código XAML:

 

   1: <UserControl x:Class="Client.Aplicacion.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:              xmlns:vistas="clr-namespace:Client.Views;assembly=Client.Views"

   7:     mc:Ignorable="d"

   8:     d:DesignHeight="353" d:DesignWidth="553">

   9:  

  10:     <Grid x:Name="LayoutRoot" Background="White">

  11:         

  12:               <vistas:uCategorias HorizontalAlignment="Left" Margin="270,99,0,0"

  13:  Name="uCategorias1" VerticalAlignment="Top" />

  14:     </Grid>

  15: </UserControl>

Bueno espero que os sea de utilidad y nos vemos en los próximos posts!.

 

Saludos!

[SL] Domain operations cannot be started at design time

Introducción

Mientras estaba preparando un post acerca de SL y MVVM, estaba generando los proyectos y me he encontrado con este error al estar en tiempo de diseño:

“Domain operations cannot be started at design time”

Descripción

Este error se produce cuando estamos accediendo en tiempo de diseño a nuestros datos.

En el caso que atañe, estaba creando un UserControl, que enlazaba con una ViewModel (más adelante veremos que es) y en el código de la vista enlazaba con el Domain Service que definimos en el post anterior.

En concreto el código que generaba el problema era:

   1: public uCategorias()

   2: {

   3:     InitializeComponent();

   4:     this.Loaded += new RoutedEventHandler(uCategorias_Loaded);

   5: }

   6:  

   7: void uCategorias_Loaded(object sender, RoutedEventArgs e)

   8: {

   9:     this.DataContext = new ViewModels.vmCategorias();

  10: }

 

Solución

Para corregirlo, basta con lo siguiente:

– Agregar un Using a “System.ComponentModel”

– Preguntar si estamos en la herramienta de diseño.

 

El código corregido sería:

   1: public uCategorias()

   2: {

   3:     InitializeComponent();

   4:     this.Loaded += new RoutedEventHandler(uCategorias_Loaded);

   5: }

   6:  

   7: void uCategorias_Loaded(object sender, RoutedEventArgs e)

   8: {

   9:     if (DesignerProperties.IsInDesignTool)

  10:         return;

  11:     this.DataContext = new ViewModels.vmCategorias();

  12: }

 

Espero que os sea de utilidad.

 

Saludos!

[SL] Acceder a una Base de Datos desde Silverlight

En primer lugar decir, como ya dije en el anterior post de SL, que soy muy nuevo en el desarrollo de SL así que espero FeedBack de cosas mejorables :p.

Introducción

El objeto de este post, es definir la estructura básica y ver como consumir datos de una Base de Datos desde Silverlight.

Primer Paso:

Crear un proyecto del tipo Librería de Clases en C# que llamaremos: Server.Datos

Este proyecto va a contener el código relacionado con el manejo de Base de Datos, en este ejemplo vamos a utilizar Entity Framework,
por lo tanto agregaremos un  nuevo fichero del Tipo Entity Data Model y configuraremos la conexión a la Base de Datos (Para este ejemplo
estoy utilizando la BD de ejemplo Northwind).

Segundo Paso:

Vamos a agregar otro proyecto de tipo librería de clases que llamaremos Server.Servicio.

Este proyecto va a ser el encargado de suministrar los servicios de comunicación con la Base de Datos indicada en el proyecto anterior.

El primer paso de este proyecto será establecer una referencia al proyecto "Server.Datos". y generar la solución para que detecte las clases generadas
en EF.

Después agregaremos un fichero de tipo DomainDataServices al proyecto:

Nos pedirá que configuremos el objeto que va a servir como contexto, y por defecto aparecerá seleccionado el que creamos en el proyecto anterior.
También aparecerán listadas todas las entidades de nuestro contexto, y si son editables o no. Para este ejemplo únicamente seleccionaremos la tabla
"Categories".

Al pulsar aceptar, va a generar una clase con los métodos necesarios para insertar, actualizar o borrar datos de nuestra BD.

Tercer Paso:

A continuación vamos a agregar un nuevo proyecto de tipo Silverlight Application al que llamaremos Client.Aplicacion. Al agregar este proyecto
nos creará solicitará en que tipo de proyecto vamos a alejar nuestra aplicación, por defecto viene ASP.NET Web Application así que dejaremos ese, y
la versión de Silverlight 4.

Una vez creado este proyecto, veremos que en la aplicación también se ha creado un proyecto del tipo indicado antes (ASP.NEt Web Application) llamado
Aplicacion.Web.

Dentro de este proyecto vamos a modificar la configuración del Web.Config:

En el apartado Configuration vamos a agregar la referencia para trabajar con Entidades (EF)

 

   1: <httpModules>

   2:   <add name="DomainServiceModule" 

   3:        type="System.ServiceModel.DomainServices.Hosting.DomainServiceHttpModule, 

   4:        System.ServiceModel.DomainServices.Hosting, Version=4.0.0.0,

   5:        Culture=neutral, PublicKeyToken=31BF3856AD364E35" />

   6: </httpModules>

Después agregaremos el siguiente fragmento:

   1: <system.serviceModel>

   2:   <serviceHostingEnvironment aspNetCompatibilityEnabled="true" 

   3:     multipleSiteBindingsEnabled="true" />

   4: </system.serviceModel> 

También agregaremos la cadena de conexión a la Base de Datos, tal cual la ha creado el modelo de EF.

Por ultimo dentro del proyecto Web agregaremos una referencia al proyecto Server.Servicio.

Mostrando Datos

Bien para poder mostrar datos, vamos a empezar a definir el XAML:

       

   1: <ListBox   Grid.Column="0" x:Name="listadoCategorias">

   2:             <ListBox.ItemTemplate>

   3:                 <DataTemplate>

   4:                     <Grid>

   5:                         <Grid.ColumnDefinitions>

   6:                             <ColumnDefinition/>

   7:                             <ColumnDefinition/>

   8:                         </Grid.ColumnDefinitions>

   9:                         <TextBlock Grid.Column="0" Text="{Binding CategoryName}"/>

  10:                         <TextBlock Grid.Column="1" Text="{Binding Description}"/>

  11:                     </Grid>

  12:                 </DataTemplate>

  13:             </ListBox.ItemTemplate>            

  14:         </ListBox>

Y en el CodeBehind vamos a  escribir el siguiente código:

   1: var context = new Server.Servicio.dServicio();

   2: context.Load(context.GetCategoriesQuery());

   3: listadoCategorias.ItemsSource = context.Categories;

 

En próximos posts, veremos como introducirnos en el uso del patrón MVVM y su uso con Silverlight.

 

Espero que os sea de utilidad.

 

Saludos.

 

PD: Os dejo el enlace a la descarga del proyecto de ejemplo.

[SL] Maestro – Detalle y la propiedad IsSynchronizedWithCurrentItem

Introducción

Estoy dando mis primeros pasos en el mundo de WPF y Silverlight. Empece por WPF donde y ahora estoy intentando migrar los ejemplos que he creado en WPF a Silverlight y me he encontrado el siguiente problema:

“Establecer la propiedad IsSynchronizedWithCurrentItem a True provoca una excepción.”

En WPF este problema no sucede así que hable con el crack de SL (Josue Yeray) y vi la ayuda de MSDN, donde dicen:

Obtiene o establece un valor que indica si Selector debe mantener la propiedad SelectedItem sincronizada con el elemento actual en la propiedad Items.

Campo identificador de la propiedad de dependencia: IsSynchronizedWithCurrentItemProperty

Establecer la propiedad IsSynchronizedWithCurrentItem en true producirá una excepción.

Lo que pretendía conseguir es un Listbox y que en unas cajas de Texto mostrase el valor del elemento seleccionado.

Para conseguirlo en WPF podríamos utilizar un código como el siguiente:

   1: <ListBox x:Name="Productos" Grid.Row="1" Grid.Column="1" IsSynchronizedWithCurrentItem="True" 

   2:     ItemsSource="{Binding lProductos}">

   3:          <ListBox.ItemTemplate>

   4:              <DataTemplate>

   5:                  <Grid>

   6:                      <Grid.ColumnDefinitions>

   7:                          <ColumnDefinition/>

   8:                      </Grid.ColumnDefinitions>

   9:                      <Label Content="{Binding Path=Nombre}"/>

  10:                  </Grid>

  11:              </DataTemplate>

  12:          </ListBox.ItemTemplate>

  13:      </ListBox>

  14:      <StackPanel  Grid.Row="1" Grid.Column="2">

  15:          <Label Content="Producto"/>

  16:          <TextBlock Text="{Binding CurrentItem.Nombre}" Height="26" />

  17:          <Label Content="Unidades"/>

  18:          <TextBlock Text="{Binding CurrentItem.Unidades}" Height="26" />

  19:          <Label Content="Precio"/>

  20:          <TextBlock x:Name="txtPrecio" Text="{Binding CurrentItem.Precio}" Height="26" />

  21:      </StackPanel>

Solución para SilverLight

En vista de no poder utilizar la propiedad indicada, vamos a enlazar los Textos a la propiedad SelectedItem del ListBox:

   1: <ListBox   Grid.Column="0" x:Name="listadoActividades" ItemsSource="{Binding Actividades}">

   2:             <ListBox.ItemTemplate>

   3:                 <DataTemplate>

   4:                     <Grid>

   5:                         <Grid.RowDefinitions>

   6:                             <RowDefinition/>

   7:                         </Grid.RowDefinitions>

   8:                         <Grid.ColumnDefinitions>

   9:                             <ColumnDefinition/>

  10:                             <ColumnDefinition/>

  11:                             <ColumnDefinition/>

  12:                         </Grid.ColumnDefinitions>

  13:                         <TextBlock Grid.Column="0" Text="{Binding AC_Codi}"/>

  14:                         <TextBlock Grid.Column="1" Text="{Binding AC_Descripcion}"/>

  15:                         <TextBlock Grid.Column="2" Text="{Binding AC_Tipo}"/>

  16:                     </Grid>

  17:                 </DataTemplate>

  18:             </ListBox.ItemTemplate>            

  19:         </ListBox>

  20:         <StackPanel Grid.Column="1">

  21:             <TextBlock Text="Codigo"/>

  22:             <TextBox  Text="{Binding ElementName=listadoActividades, Path=SelectedItem.AC_Codi}" 

  23:             IsEnabled="False"/>

  24:             <TextBlock Text="Descripción"/>

  25:             <TextBox Text="{Binding ElementName=listadoActividades, 

  26:                             Path=SelectedItem.AC_Descripcion, Mode=TwoWay}"/>

  27:             <TextBlock Text="Tipo de Actividad"/>

  28:             <TextBox Text="{Binding ElementName=listadoActividades, 

  29:                             Path=SelectedItem.AC_Tipo, Mode=TwoWay}"/>

  30:         </StackPanel>

 

Bueno espero que os sea de utilidad.

 

Saludos.