El blog de Javier Torrecilla : WPF

[WINRT] Behaviors

Javier Torrecilla — Thu, 24 Jan 2013 18:03:48 GMT

El patrón de diseño mas utilizado a la hora de crear aplicaciones con WPF, Silverlight o Windows 8 es MVVM (Model – View – ViewModel).

Aunque no voy a entrar a la explicación de este patrón voy a hablar de algo relacionado con él.

Uno de los objetivos de este patrón es ayudarnos a mantener nuestro código lo mejor estructurado posible.

En este post me voy a centrar en explicar una problemática existente dentro de Windows 8 y mas concretamente en las desarrolladas con XAML.

El problema radica en la no existencia de triggers que si existian en WPF, como podían ser EventTrigger que se producian al lanzarse un evento.

Debido a ello, vamos a ver como podemos extender los controles de WINRT, para que en lugar de utilizar los eventos desde el código de nuestra página / control, enlacemos a través de un Binding con una propiedad ICommand de nuestro modelo.

Para poder hacer esto, sera necesario definir una Dependency Property. Para el ejemplo concreto vamos a ver como capturar una tecla pulsada por ejemplo en un control de tipo TextBox:

        1: public class PageKeyPressBehavior

       2: {

       3:     public static readonly DependencyProperty KeyDownCommandProperty = DependencyProperty.RegisterAttached("KeyDownCommand", typeof(ICommand), typeof(PageKeyPressBehavior),

       4:                 new PropertyMetadata(DependencyProperty.UnsetValue,

       5:                     (o, e) =>

       6:                     {

       7:                         var textbox = o as TextBox;

       8:                         if (textbox != null)

       9:                         {

                            if (e.NewValue != null && e.OldValue == null)

                                textbox.KeyDown +=  KeyDownEvent;

                            else if (e.NewValue == null && e.OldValue != null)

                                textbox.KeyDown -= textbox_KeyDownEvent;

                        }

                    }));

 

            public static ICommand GetIntroButtonCommand(UIElement element)

            {

                return (ICommand)element.GetValue(IntroButtonCommandProperty);

            }

 

            public static void SetIntroButtonCommand(UIElement element, ICommand value)

            {

                element.SetValue(IntroButtonCommandProperty, value);

            }

 

            static void KeyDownEvent(object sender, Windows.UI.Xaml.Input.KeyRoutedEventArgs e)

            {

                    var textbox = sender as TextBox;

                    if (textbox != null)

                    {

                        ICommand cmd = GetIntroButtonCommand(textbox);

                        if (cmd != null)

                            cmd.Execute(e.Key.ToString());

                       

                    }   

            }

}

En el código del ejemplo lo que hacemos es registrar una propiedad en los controles de tipo TextBox, y agregamos el manejador de eventos para controlar el evento KeyDown. Dentro de dicho evento lo que haremos será invocar al valor de nuestra Dependency Property.

Bien, ahora como utilizamos esto dentro de nuestra pagina:

1) Lo primero será agregar el namespace donde está alojada la clase que incluye nuestra Dependency Property:

       1: xmlns:be="using:MyApp.Behaviors"

2) Utilizarla dentro de nuestro TextBox:

       1: <TextBox be:KeyDownCommand="{Binding MyKeyDownCommand}" />

Con esto ya trendriamos enlazado nuestro ViewModel y nuestra Vista sin tener que capturar los eventos desde el propio Code Behind.

Espero que os sea de utilidad.

Saludos!

[VS2012] Información del llamante

Javier Torrecilla — Fri, 20 Jul 2012 07:01:00 GMT

Introducción:

Lo primero que poco me gustan algunas traducciones, así que vamos a llamar las cosas por su nombre, en este post vamos a hablar de una de las novedades de .NET 4.5 “Caller Information”.

Una de las cosas novedosas de esta nueva versión del Framework viene a facilitarnos la vida a la hora de realizar trace y log de errores de nuestras aplicaciones (aunque en este post vamos a ver otra utilidad de esta información).

Dentro del espacio de nombres “System.Runtime.CompilationServices” se han agregado tres atributos que van a poder ser aplicados sobre parámetros de un método:

- CallerFilePath: Va a cualificar un parámetro que almacenará el nombre del fichero que ha provocado la llamada.

- CallerLineNumber: Va a cualificar un parámetro que indicará la línea donde se encontraba la llamada al método.

- CallerMemberName: Va a cualificar un parámetro que indicará el nombre del método que contenía la llamada.

La aplicación de estos atributos, se realizará sobre parametros opcionales, los cuales tendrán que ser inicializados con algun valor:

public static  void Log([CallerFilePath]string path="",[CallerLineNumber]int line=0,[CallerMemberName] string method="")
{
//Do Actions
}

Podríamos invocar a este método desde cualquier parte de la aplicación y tendríamos la información indicada.

Os dejo un ejemplo de una aplicación de consola para que veais el funcionamiento.

Un ejemplo:

Un sitio donde puede ser interesante de utilizar es en la implementación del patrón MVVM (que tanto trabajo va a tener de cara al futuro).

Podríamos aplicarlo al definir un ViewModelBase donde se realice la implementación del evento PropertyChanged:

   1:  public class VMBase : INotifyPropertyChanged

   2:     {

   3:         public event PropertyChangedEventHandler PropertyChanged;

   4:         public void ChangeProperty([CallerMemberName]string property = "")

   5:         {

   6:             if (PropertyChanged != null)

   7:                 PropertyChanged(this, new PropertyChangedEventArgs(property));

   8:             MessageBox.Show(property);

   9:         }

  10:     }

Espero que os sea de utilidad.

Saludos!!!

WinRT: Establecer un estilo Condicional (2) #Metro #Win8

Javier Torrecilla — Thu, 26 Apr 2012 08:17:00 GMT

Introducción

Ayer publique una entrada en la que hablaba de aplicar un estilo condicional a un control en xaml.

Después de revisar si se puede utilizar StyleSelector o DataTemplateSelector, ambos son válidos a aplicar para un control como el ListBox, pero no por ejemplo para un TextBox o un TextBlock.

Código V2:

Dandole una pequeña vuelta de tuerca, y a pesar que me sigue pareciendo un “Bad Code Smell”, me he creado un nuevo converter:

public class BooleanStyleConverter : IValueConverter

{

  

    public object Convert(object value, Type targetType, object parameter, string language)

    {

        var page = new MyXamlPage();

  

        return ((bool)value ? page.Resources["StyleA"] as Style : page.Resources["StyleB"] as Style);

    }

  

    public object ConvertBack(object value, Type targetType, object parameter, string language)

    {

        throw new NotImplementedException();

    }

}

En el converter se define la pagina donde se encuentran los estilos, y nuestro control, y a través del diccionario de recursos devolvemos un estilo según nuestro condicionante.

Su aplicación en código:

1) Definir el converter en los recursos:

   1: <converters:BooleanStyleConverter x:Name="GenderConverter"/>

2) Definir nuestro control con su Binding y Converter:

   1: <TextBlock Text="{Binding Child.Name}" Style="{Binding Child.Gender,Converter={StaticResource GenderConverter}}" />

Espero que os sea de utilidad, o si veis alguna opción mejor, lo comenteis

Saludos!

[TIP] Exportar Word a PDF desde Código

Javier Torrecilla — Fri, 16 Mar 2012 10:25:09 GMT

Mini artículo para exportar un fichero word a PDF desde código c# y VB.NET.

Al Lio

Para poder trabajar con documentos de Word en nuestro código es necesario que agreguemos la referencia “Microsoft.Office.Interop.Word.dll”.

Sin mas dilación el código:

VB.NET

        1: Dim app As New Microsoft.Office.Interop.Word.Application()

       2:  

       3:         Dim missing As Object = System.Type.Missing

       4:         Try

       5:  

       6:                 Dim document As Microsoft.Office.Interop.Word.Document = app.Documents.Open(RutaCarta)

       7:                 Dim nombre As String = String.Format("{0}\TEMP\Name.doc", Application.StartupPath)

       8:  

       9:                 app.Visible = False

      10:                 

      11:                 app.ActiveDocument.ExportAsFixedFormat(String.Format("{0}\Name.pdf", Application.StartupPath), & _

      12:                      Microsoft.Office.Interop.Word.WdExportFormat.wdExportFormatPDF, False, & _

      13:                         Microsoft.Office.Interop.Word.WdExportOptimizeFor.wdExportOptimizeForPrint, & _

      14:                     Microsoft.Office.Interop.Word.WdExportRange.wdExportAllDocument)

      15:                 document.Close()

      16:    

      17:         Catch ex As Exception

      18: 'Manejar la excepción....

      19:         Finally

      20:  

      21:             app.Quit()

      22:  

      23:         End Try

       1: var app = New Microsoft.Office.Interop.Word.Application()

       2: var missing = System.Type.Missing

       3: try

       4: {

       5:     var document = app.Documents.Open(RutaCarta);

       6:     string nombre = String.Format("{0}\TEMP\Name.doc", Application.StartupPath);

       7:     app.Visible = false;

       8:                 

       9:        app.ActiveDocument.ExportAsFixedFormat(String.Format("{0}\Name.pdf", Application.StartupPath), 

      10:                      Microsoft.Office.Interop.Word.WdExportFormat.wdExportFormatPDF, False, 

      11:                         Microsoft.Office.Interop.Word.WdExportOptimizeFor.wdExportOptimizeForPrint, 

      12:                     Microsoft.Office.Interop.Word.WdExportRange.wdExportAllDocument);

      13:                 document.Close();

      14: }

      15: catch(Exception ex)

      16: {

      17: 'Manejar la excepción....

      18:  }

      19: finally

      20: {

      21:     app.Quit();

      22: }

Gracias al método ExportAsFixedFormat, podremos exportar nuestro fichero Word a formato PDF o XPS…

…PERO!!!:

Podremos encontrarnos una excepción que nos dirá algo así: “Esta funcionalidad no está instalada.”.

Para poder ejecutar de forma correcta este código, necesitamos instalar un addin de Office.

Espero que os sea de utilidad.

Saludos!!!

DbMigration y Code First

Javier Torrecilla — Fri, 16 Mar 2012 08:54:00 GMT

Introducción

Una de las novedades que se introdujo con la versión 4.3 de Entity Framework son las llamadas Database Migration (DbMigration), que vienen a satisfacer las necesidades de los desarrolladores a la hora de realizar cambios en la estructura de la base de datos, como por ejemplo:

- Creación o borrado de Tablas.

- Cambiar o quitar columnas.

- entre otras cosas :)

La principal problemática venía a la hora de tener nuestra aplicación instalada en varios clientes y que tengan distintas versiones de Base de Datos.

Empezando

Para poder empezar a utilizar DbMigration es necesario que al “menos” tengamos instalada la versión 4.3.1(*) de Entity Framework, si no podremos instalarla desde nuget o desde la consola de comandos:

   1: Install-Package EntityFramework 

(*) Se encuentra en fase beta la version 5.0 de Entity Framework.

A continuación desde la consola de comandos, tendremos que especificar la habilitación de migraciones para nuestro proyecto, para ello ejecutaremos el comando “Enable-Migrations”.

Esta acción va a realizar los siguientes procesos:

- Va a buscar una clase dentro de nuestro proyecto que implemente la clase DBContext, para utilizar dicho contexto a la hora de definir las migraciones.

- Va a crear una nueva carpeta “Migrations” en nuestro proyecto. Esta carpeta va a contener los siguientes ficheros:

1. Clase Configuration.cs: Esta clase va a ser una implementación de la clase base genérica DbMigrationsConfiguration con nuestro objeto contexto.
  Dentro de ella, vamos a poder definir la configuración de la migración (en el constructor) y si hay que hacer algun proceso de llenado de información (método Seed).
2. Una Migración Inicial: va a definir una clase que implemente la clase Base DbMigration, donde tendremos el método Up con la creación de nuestras entidades, y el método Down con el borrado de las mismas. La implementación de las migraciones se realiza en dos partes, la primera es la que acabamos de ver, y la segunda es relativa a información que se va a almacenar en la Base de Datos.

- Va a crear una tabla dentro de nuestra Base de Datos llamada __MigrationHistory que va a almacenar información relativa a las migraciones.

¿Cómo crear una Migración?

Bien para crear una nueva migración desde la consola de comandos ejecutaremos la siguiente instrucción:

“Add-Migration Name”

Al ejecutarlo, se va a generar una nueva clase dentro de la carpeta Migrations, con una estructura similar a la mencionada anteriormente con la migración inicial.

Dentro de dicha clase vamos a tener que implementar los métodos Up, para subir de versión, y Down para bajar de versión.

¿Qué Métodos podemos utilizar en los métodos Up y Down?

AddColumn	AddForeignKey	AddPrimaryKey
AlterColumn	CreateIndex	CreateTable<T>
DropColumn	DropForeignKey	DropPrimaryKey
DropIndex	DropTable	MoveTable
RenameColumn	RenameTable	SQL

Ejemplo:

public partial class ProductMigration : DbMigration

    {

        public override void Up()

        {

            CreateTable("Products",

                columns => new

                {

                    ProductId = columns.Int(identity: true),

                    Name = columns.String(maxLength: 100),

                    Description = columns.String(),

                    Price = columns.Decimal(precision: 10, scale: 2)

                });

        }

        

        public override void Down()

        {

            DropTable("Products");

        }

    }

¿Cómo actualizar la Base de Datos?

Para poder ejecutar una migración tenemos dos posibles formas:

1) Desde la consola de Comandos:

A través del comando “Update-Database”. Los parámetros del comando son:

- SourceMigration <String>
- TargetMigration <String>
- Script [<SwitchParameter>]
- Force [<SwitchParameter>]
- ProjectName <String>
- StartUpProjectName <String>
- ConfigurationTypeName <String>
- ConnectionStringName <String>
- ConnectionString <String>
- ConnectionProviderName <String>

2) Desde código:

Definiremos un objeto del tipo Configuration, otro del tipo DbMigrator, y ejecutaremos el método Update:

var config = new Migrations.Configuration();

            var migrator = new DbMigrator(config);

            migrator.Update();

Esta acción va a ejecutar la actualización a la ultima versión de la Base de Datos. En el caso de desear ejecutar una migración concreta o volver a una versión determinada, ejecutaríamos de la siguiente manera:

var config = new Migrations.Configuration();

var migrator = new DbMigrator(config);

migrator.Update("201203140720163_InitialCreate");

Espero que os resulte de utilidad.

Saludos!

#ORAPOCO: V2.1

Javier Torrecilla — Wed, 15 Feb 2012 09:28:13 GMT

Continuando con mi particular cruzada de crear un Mini ORM para trabajar con ORACLE, publico una nueva versión de ORAPOCO.

Historia:

OraPoco V2.0

OraPoco Update 2

OraPoco Primer Update

OraPoco 1.0

¿Qué incluye esta nueva versión?

- Corrección de un pequeño bug.

- Mejora en el rendimiento de la obtención de resultados de la base de Datos.

- BulkInsert: Permite la inserción de datos a través de OracleBulkInsert. Es bastante más rápido que ejecutar las inserciones por separados, pero no tan rápido que utilizar BulkInsert directamente puesto que es necesario hacer una serie de conversiones.

Ejemplo:

        1: Enumerable.Range(1, 300000).AsParallel().ForAll(a =>

       2: {

       3:     datos.Add(new BL_BLOQUEO_PANTALLA

       4:     {

       5:         BLPA_FECHA = DateTime.Now.ToShortDateString(),

       6:         BLPA_HORA = DateTime.Now.ToShortTimeString(),

       7:         BLPA_PANTALLA = "",

       8:         BLPA_USUARIO = "1",

       9:         BLPA_ID = a

      10:     });

      11: });

      12: db.BulkInsert<BL_BLOQUEO_PANTALLA>(datos);

¿Qué es lo que vendrá?

Proyecto de Testing, Mejoras y más equivalencia de tipos de Oracle, Procedimientos Almacenados…

Como siempre os pido un poquito de feedback si lo probáis.

Enlaces de Descarga:

- GitHub.

- Nuget

Saludos!!!

[ORM-Lite] PetaPoco

Javier Torrecilla — Tue, 10 Jan 2012 10:06:00 GMT

Introducción En este post voy a continuar la serie acerca de ORMS ligeros donde ya he hablado de Dapper y Massive , en esta ocasion voy a tratar PetaPoco. ¿Qué es PetaPoco? PetaPoco es otro mini ORM basado en Massive , pero a diferencia de este para trabajar con objetos POCO. Algunas de sus caracteristicas: - Es un único fichero que sea agrega al proyecto. - Permite trabajar con objetos POCO. - Permite la generación de los objetos POCO a través de unas plantillas...(read more)

[ORM-Lite] Massive

Javier Torrecilla — Mon, 09 Jan 2012 09:55:13 GMT

Introducción

Hace unos días realice una entrada sobre Dapper un mini ORM, y como ya comente iba a realizar una serie sobre más ejemplos de ORM ligeros. En esta ocasión le ha tocado a Massive.

¿Qué es Massive?

Bien Massive es otro ORM ligero creado por Rob Conery(Blog y Twitter), que nos permite realizar consultas a una Base de datos y su explotación en un sistema a través de objetos Expando.

¿Por dónde empezar?

Para poder trabajar con Massive, tenemos dos posibilidades:

- Agregarlo como un paquete a nuestro proyecto desde Nuget (No es la ultima versión a fecha de hoy)

- Descargar el único fichero que genera desde GitHub.

Existe un fichero disponible para los siguientes tipos de Base de datos:

- Sql Server.

- Oracle.

- SQLLite.

- PostgreSQL.

Para este post vamos a utilizar el de SQL Server, y la misma tabla que vimos el otro día sobre “CandidateInfo”.

Algunos Ejemplos

Vamos a ver algunos ejemplos de la utilización de Massive dentro de un proyecto de .NET.

El primer paso, como decía antes, será agregar la clase de Massive a nuestro proyecto.

A continuación vamos a definir una clase que va servir para trabajar con la tabla CandidateInfo de nuestra Base de Datos:

        1: public class CandidateInfo : Massive.DynamicModel 

       2:  {

       3:     public CandidateInfo() : base("MyCV","CandidateInfo","CandidateId")

       4:     {

       5:          

       6:     }

       7:  }

Nuestra clase CandidateInfo va a heredar de la Clase DynamicModel, y vamos a hacer que se implemente el constructor base, indicándole los siguientes parámetros:

- Cadena de Conexión: conexión existente en el fichero de configuración de la aplicación que queremos utilizar.

- Nombre de la tabla que queremos utilizar.

- Campo clave de la tabla.

Una vez definida nuestra clase vamos a ver los propios ejemplos:

Consulta de Datos

Para realizar una simple consulta de datos, vamos a necesitar declarar un objeto del tipo de la clase anteriormente indicada:

       1: var candidateInfo = new App_Code.CandidateInfo();

Una vez definida nuestra tabla, vamos a obtener:

- Todos los resultados:

       1: var query = candidateInfo.All();

       2: foreach (var candidato in query)

       3: {

       4:     var dictionary = ObjectExtensions.ToDictionary(candidato);

       5:     foreach (var item in dictionary)

       6:     {

       7:         Console.WriteLine(String.Format("{0} : {1}", item.Key, item.Value));

       8:     }

       9: }

- Resultados Filtrados:

       1: var query = candidateInfo.All("CandidateName like '%a%'");

       2: foreach (var candidato in query)

       3: {

       4:     var dictionary = ObjectExtensions.ToDictionary(candidato);

       5:     foreach (var item in dictionary)

       6:     {

       7:         Console.WriteLine(String.Format("{0} : {1}", item.Key, item.Value));

       8:     }

       9: }

El Método All, dispone de los siguientes parámetros:

- Where: para realizar un filtro.

- Order: para establecer el orden de los resultados.

- Limit: Para establecer un Top de los resultados.

- Columnas: para indicar que columnas se van a establecer.

- Parámetros: se pueden establecer los valores del filtro como parámetros.

Todos los parámetros son opcionales.

Al tratarse de tipos anónimos podríamos realizar la siguiente consulta:

       1: var query =  candidateInfo.Query(

       2:                "Select CandidateName,CountryName from CandidateInfo inner join CountryInfo on CountryId=CandidateCountry");

       3:  

       4:            

       5:            foreach(var dato in query)

       6:            {

       7:  

       8:                var dictionary = ObjectExtensions.ToDictionary(dato);

       9:                foreach (var item in dictionary)

      10:                {

      11:                    Console.WriteLine(String.Format("{0} : {1}", item.Key, item.Value));

      12:                }

      13:            }

Como crear un nuevo registro:

       1: var dato = candidateInfo.Insert(new

       2:                              {

       3:                                  CandidateName = "Javier",

       4:                                  CandidateLastName = "Torrecilla",

       5:                                  CandidateBirthDate = DateTime.Now,

       6:                                  CandidateCountry = 1,

       7:                                  CandidateCity = 1,

       8:                                  CandidateEmail = "r@yahoo.es"

       9:                              });

Como realizar la eliminación de un registro:

   1:  int delete = candidateInfo.Delete(@where: "CandidateName =@0", args: "j");

Como realizar una actualización de un dato:

   1:   candidateInfo.Update(new {CandidateLastName = "Torrecilla Puertas"}, guid);

También existe la posibilidad de ejecutar una sentencia sql, un ojbeto DBCommand o una lista de DBCommand a través del método Execute.

Conclusiones

Massive, nos provee una forma bastante rápida de manejar nuestra Base de Datos, sin tener que escribir gran cantidad de código.

Nos da la flexibilidad que aporta dynamic y el trabajo con tipos anónimos.

Por otro lado, al ser un único fichero podemos realizar nuestras propias modificaciones, aunque nos salgamos de la línea definida por Rob.

El próximo post de la serie será acerca de PetaPoco

Dapper Dot Net

Javier Torrecilla — Tue, 03 Jan 2012 10:13:16 GMT

Introducción

Hace unos días Jorge Gamba comentaba en un twit algunos ORMS Ligeros para utilizar en algunos proyectos donde realmente no se requiere la potencia de Entity Framework o NHibernate. Esto venía a través de un intenso debate (y lucha) para intentar dejar a un lado los DataSets y DataTables que se utilizaban antiguamente.

¿Qué es Dapper?

Podríamos decir que Dapper es un mini-ORM (o un ORM Lite) compuesto por un conjunto de clases que nos van a permitir mapear nuestra base de datos con nuestras clases POCO.

Este “ORM” es independiente de la Base de Datos, puesto que hace uso de la interfaz IDbConnection, ya la mayoría de conexiones (SQL Server, Oracle, My SQL, OLEDB) tienen una Clase connection que implementa dicha interfaz.

¿Por donde empezar?

Para poder empezar a utilizar Dapper (no lo busquéis en Nuget, no está aún), tenéis que descargar un único fichero CS y agregarlo en vuestro proyecto de Visual Studio.

Algunos ejemplos

Vamos a ver algunos ejemplos muy sencillos de como utilizar Dapper, y ver la simplicidad de utilización que nos aporta:

Lo primero que vamos a hacer es declarar una variable conexión del tipo IDbConnection, para que podamos modificar el motor de Base de Datos de una forma muy rapida:

        1: IDbConnection connection;

CONSULTA DE DATOS

El primer ejemplo lo voy a realizar sobre una Base de Datos SQL Server Express, y contra una tabla “Candidates” que voy a mapear a una clase como la siguiente:

       1: public class CandidateInfo

       2:  {

       3:     public Guid CandidateId { get; set; }

       4:     public string CandidateName { get; set; }

       5:     public string CandidateLastName { get; set; }

       6:     public DateTime CandidateBirthDate { get; set; }

       7:     public byte[] CandidatePhoto { get; set; }

       8:     public int CandidateCountry { get; set; }

       9:     public int CandidateCity { get; set; }

      10:     public string CandidateEmail { get; set; }

      11:  }

Para obtener el conjunto de resultados de la tabla Candidates, ejecutariamos este bloque de código:

       1: using (connection = new SqlConnection(@"Data Source=.\SQLEXPRESS;Initial Catalog=MYCV;Integrated Security=True"))

       2: {

       3:     connection.Open();

       4:     var Candidates = Dapper.SqlMapper.Query<CandidateInfo>(connection, "Select * From CandidateInfo");

       5:  

       6: }

La Clase SqlMapper, está incluida en el fichero que hemos descargado. A través del método genérico Query se realiza el “mapeo” de la consulta que enviamos como parámetro al método.

Si en lugar de utilizar SQL Server estuviéramos usando cualquier otro tipo de BD, bastaría con modificar el bloque using y utilizar la clase de conexión del motor que tengamos.

El segundo ejemplo, va a ser para devolver un único tipo de dato simple:

       1: using (connection = new SqlConnection(@"Data Source=.\SQLEXPRESS;Initial Catalog=MYCV;Integrated Security=True"))

       2:     {

       3:         connection.Open();

       4:         var Candidates = Dapper.SqlMapper.Query<int>(connection, "Select CandidateCountry From CandidateInfo");

       5:     }

       6:

En este caso vamos a obtener un conjunto de datos “int”.

A continuación, vamos a ver como utilizar parámetros:

       1: using (connection = new SqlConnection(@"Data Source=.\SQLEXPRESS;Initial Catalog=MYCV;Integrated Security=True"))

       2: {

       3:     connection.Open();

       4:     var Candidates = Dapper.SqlMapper.Query<CandidateInfo>

       5:         (connection,

       6:         "Select * From CandidateInfo where CandidateLastName like @a",

       7:        new { a = "%Puertas%" });

       8: }

El tercer parámetro del método Query, va a ser un array dinámico de Pares valor que se enlazarán a los parámetros de la query definida.

Ejemplo de consulta multiple, vamos a definir un conjunto de consultas contra el servidor y sus relativos Mapeos. Para este ejemplo vamos a hacer uso también de la siguiente clase:

       1: public class CountryInfo

       2: {

       3:     public int CountryID { get; set; }

       4:     public string CountryName { get; set; }

       5: }

       6:

El ejemplo consistirá en obtener la información de Candidates y Country:

       1: using (connection = new SqlConnection(@"Data Source=.\SQLEXPRESS;Initial Catalog=MYCV;Integrated Security=True"))

       2: {

       3:     connection.Open();

       4:     var sql =

       5:         @"

       6:         select * from CandidateInfo

       7:         select * from CountryInfo";

       8:         using (var multi = Dapper.SqlMapper.QueryMultiple(connection, sql))

       9:         {

      10:             var candidates = multi.Read<CandidateInfo>().ToList();

      11:             var countries = multi.Read<CountryInfo>().ToList();

      12:         }

      13: }

El método QueryMultiple se encargará de dividir las consulta SQL en varías, y el objeto GridReader existente en el fichero descargado se encargará de realizar los mapeos de cada una de las consultas a través del método genérico Read.

Por otro lado, también existe la posibilidad de utilizar procedimientos almacenados y mapearlo a las entidades de las que disponemos.

EJECUCIÓN DE SENTENCIAS

Una cosa que se encuentra en la cola de solicitudes / incidencias de Dapper, es que no tiene un método de inserción, actualización o borrado directo, pero se pueden ejecutar este tipo de sentencias de manera muy sencilla:

Ejemplo de Inserción simple:

       1: using (connection = new SqlConnection(@"Data Source=.\SQLEXPRESS;Initial Catalog=MYCV;Integrated Security=True"))

       2:            {

       3:                connection.Open();

       4:               

       5:                Dapper.SqlMapper.Execute(connection, 

       6:                                         "INSERT INTO COUNTRYINFO (COUNTRYNAME) VALUES(@COUNTRY)",

       7:                                        new { COUNTRY = "Benin" });

       8:            }

Ejemplo de Inserción múltiple (va a ejecutar la misma sentencia, cambiando los valores de los parámetros según la lista de valores que dispongamos):

       1: using (connection = new SqlConnection(@"Data Source=.\SQLEXPRESS;Initial Catalog=MYCV;Integrated Security=True"))

       2: {

       3:     connection.Open();

       4:  

       5:     var lista = new List<dynamic>();

       6:     lista.Add(new { COUNTRY = "Italia" });

       7:     lista.Add(new { COUNTRY = "Francia" });

       8:     lista.Add(new { COUNTRY = "Alemania" });

       9:     Dapper.SqlMapper.Execute(connection, "INSERT INTO COUNTRYINFO (COUNTRYNAME) VALUES(@COUNTRY)",

      10:        lista);

      11: }

Existe la posibilidad de hacer uso de transacciones (IDbTransaction) a la hora de ejecutar las sentencias, ya que el método Execute dispone de un parámetro opcional que la puede administrar, pero para hacer la confirmación (“Commit”) sería necesario ejecutarlo después de la ejecución.

Conclusiones

Dapper presenta algunas funcionalidades curiosas y unos tiempos (que veremos en una futura comparativa que voy a publicar) bastante interesantes, y que habría que tenerlo en cuenta, tal como decía al principio, si no necesitamos la potencia de algo mas grande.

Voy a realizar el análisis de otras herramientas similares a Dapper y al final publicaré una comparativa sobre tiempos.

How To: Utilizar PrincipalPermission para bloquear Funcionalidades

Javier Torrecilla — Mon, 03 Oct 2011 14:20:00 GMT

Introducción

Hace unos días hablando con Antiocol, comentábamos sobre como llevar a cabo el bloqueo de funcionalidades / pantallas / vistas ante la existencia de distintos usuarios propios de la aplicación, es decir, no son usuarios de Windows.

Me comento la existencia del atributo PrincipalPermission, y decidí investigar un poco acerca de este tema.

El problema

Dada una aplicación multiusuario, en el que encontramos los perfiles: Encargado, Dependiente y Mozo, tenemos una serie de controles de Usuario(WPF) o formularios(Winforms) que no van a ser accesibles por todos ellos.

Dentro de nuestra Base de Datos, no voy a entrar a su definición, tenemos una serie de usuarios y la asociación con los distintos perfiles, por ejemplo: Juan puede ser Encargado, dependiente y Mozo, y Pedro solo es mozo.

Tenemos dos controles:

- Facturación que va a ser solo accesible por el perfil Encargado.

- Almacén: que va a ser accesible por Encargado, Dependiente y Mozo

Para resolver, esta situación vamos a ver una posible solución con WPF, y PrincipalPermission.

Solución

Una posible aproximación para alcanzar el objetivo puede ser la siguiente:

En primer lugar, tendremos que establecer el usuario y los roles del mismo para asignárselos como Identidad a la hora de ejecutar la aplicación.

string NombreUsuario = ObtenerNombreUsuario();

GenericIdentity identidad = new GenericIdentity(NombreUsuario);

String[] roles = ObtenerRoles(NombreUsuario);

GenericPrincipal MyPrincipal =

new GenericPrincipal(identidad, roles);

Thread.CurrentPrincipal = MyPrincipal;

Una vez realizada la asignación de los permisos, va a llegar el momento de verificar si un control dado puede ser visualizado por la Identidad actual:

try

           {

               

               PrincipalPermission MyPermission =

               new PrincipalPermission(ObtenerUsuario(), "Mozo");

               // Demand this permission.

               MyPermission.Demand();

               this.DataContext = new ViewModel.Control2();

               

           }

           catch (SecurityException ex)

           {

  

               this.Visibility = Visibility.Hidden; 

           }

El método Demand se del objeto PrincipalPermission es el encargado de comprobar si el usuario tiene el rol indicado. Si el usuario dispone de dicho rol podrá visualizar el control sin ningún problema, en caso contrario, se provocará una excepción del tipo SecurityException indicándolo.

Para el correcto funcionamiento de esta solución es necesario que se incluyan los siguientes using:

- System.Security.Principal

- System.Security.Permissions

- System.Threading

- System.Security

Espero que os sea de utilidad, y que comenteis otras formas que conozcais.

Un saludo

[How To] Comprimir y Descomprimir ficheros

Javier Torrecilla — Wed, 28 Sep 2011 19:50:00 GMT

Introducción

Hoy me he percatado de la posibilidad de comprimir “un fichero” a través de .NET sin utilizar librerías de terceros".

Dentro del Namespace IO (que se encuentra dentro de System), podemos encontrar el namespace “Compression”, donde encontraremos dos clases que nos van a permitir llevar a cabo esta tarea:

GZipStream: Clase que va a permitir llevar a cabo la compresión o descompresión de un fichero.
DeflateStream: Clase que va a permitir llevar a cabo la compresión o descompresión de un fichero a través del algoritmo “Deflate”.

Este Namespace es válido desde la versión 2 de .Net Framework, pero el ejemplo que voy a utilizar sería necesario adaptarlo puesto que hago uso del método CopyTo que está disponible desde la versión 4.

Ejemplo de Uso

Para el correcto funcionamiento de los ejemplos es necesario incluir los “using” a System.IO y System.IO.Compression.

¿Cómo comprimir un fichero?

public void ComprimirFichero(string RutaFichero)

      {

          using (FileStream ficheroSalida = File.Create(String.Format("{0}.zip",RutaFichero)))

          {

              using (GZipStream zip = new GZipStream(ficheroSalida, CompressionMode.Compress))

              {

                  using (FileStream ficheroEntrada = File.OpenRead(RutaFichero))

                  {

                      ficheroEntrada.CopyTo(zip);

                  }

              }

          }

      }

¿Cómo descomprimir un fichero comprimido?

public void DescomprimirFichero(string ficheroComprimido,string rutaDestino)

       {

           using (FileStream ficheroSalida = File.Create( rutaDestino))

           {

                   using (FileStream ficheroEntrada = File.OpenRead(ficheroComprimido))

                   {

                       using (GZipStream zip = new GZipStream(ficheroEntrada, CompressionMode.Decompress))

                       {

                           zip.CopyTo(ficheroSalida);

                       }

               }

           }

       }

Conclusión

Es una opción muy a tener en cuenta si lo que se necesita es comprimir un único fichero, en el caso de necesitar compresión de más ficheros o de carpetas tendremos que evaluar opciones de terceros (en breve publicaré algo).

<a href="http://www.devify.ms" mce_href="http://www.devify.ms">Devify</a>

[XAML] ValueConverters

Javier Torrecilla — Wed, 06 Jul 2011 11:16:00 GMT

¿Qué son?

Un ValueConverter es una clase que va a permitir la conversión de un tipo de dato a otro concreto para que un enlace a datos (Binding) lo entienda.

¿Cómo se crean?

.NET ya tiene incorporados distintos conversores para ahorrar el trabajo de los desarrolladores, pero puede darse el caso que se necesite crear uno propio.

Para poder definir un ValueConverter es necesario crear una nueva clase que implemente la Interfaz IValueConverter.

Esta interfaz expone para que podamos implementar la función de Conversión, y la función de deshacer:

- Convert

- ConvertBack

Ejemplo sencillo:

Un ejemplo de creación de un ValueConverter sería la transformación de un estado de un Expediente.

Vamos a situarnos, para definir los Estados de los expedientes tenemos los distintos valores en una Enumeración:

public enum Estados

{

    Activo,

    Pendiente,

    Archivado,

    Resuelto,

    Inactivo

}

Para que de un vistazo rápido por pantalla, el usuario pueda ver los distintos estados por colores, crearemos un Conversor de Estados a Colores:

public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)

        {

            Estados es=(Estados)value;

            switch(es)

            {

                case Estados.Activo:

                    return new SolidColorBrush(Colors.Green);

                case Estados.Inactivo:

                    return new SolidColorBrush(Colors.Gray);

                case Estados.Pendiente:

                    return new SolidColorBrush(Colors.Yellow);

                case Estados.Resuelto:

                    return new SolidColorBrush(Colors.Blue);

                case Estados.Archivado:

                    return new SolidColorBrush(Colors.LightBlue);

            }

            return new SolidColorBrush(Colors.White);

        }

Bien para utilizar el ValueConverter en nuestro XAML, será necesario, que lo referenciemos e instanciemos en nuestro Control / Vista / Ventana…

<Window x:Class="Converters.MainWindow"

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

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

        xmlns:converters="clr-namespace:Converters"

        Title="MainWindow" Height="350" Width="525">

    <Window.Resources>

        

        <converters:EstadoAColorConverter x:Key="est"></converters:EstadoAColorConverter>

    </Window.Resources>

Y después en el momento de realizar el Binding utilicemos la Propiedad Converter:

<ListBox x:Name="listado" ItemsSource="{Binding}">

            <ListBox.ItemTemplate>

                <DataTemplate>

                    <Grid>

                        <TextBlock Background="{Binding Estado, Converter={StaticResource est}}" Text="{Binding Nombre}"/>

                    </Grid>

                </DataTemplate>

            </ListBox.ItemTemplate>

        </ListBox>

Espero que os sea de utilidad.!

Saludos

[XAML] Estilos

Javier Torrecilla — Thu, 30 Jun 2011 08:09:00 GMT

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

Javier Torrecilla — Tue, 28 Jun 2011 11:23:54 GMT

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

Javier Torrecilla — Mon, 27 Jun 2011 10:23:40 GMT

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

Javier Torrecilla — Thu, 09 Jun 2011 12:57:22 GMT

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:

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

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] Maestro – Detalle y la propiedad IsSynchronizedWithCurrentItem

Javier Torrecilla — Tue, 07 Jun 2011 06:05:43 GMT

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

                            <ColumnDefinition/>

                            <ColumnDefinition/>

                        </Grid.ColumnDefinitions>

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

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

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

                    </Grid>

                </DataTemplate>

            </ListBox.ItemTemplate>            

        </ListBox>

        <StackPanel Grid.Column="1">

            <TextBlock Text="Codigo"/>

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

            IsEnabled="False"/>

            <TextBlock Text="Descripción"/>

            <TextBox Text="{Binding ElementName=listadoActividades, 

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

            <TextBlock Text="Tipo de Actividad"/>

            <TextBox Text="{Binding ElementName=listadoActividades, 

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

        </StackPanel>

Bueno espero que os sea de utilidad.

Saludos.