El blog de Javier Torrecilla

[Básico]Enumerados con tipo distinto de Int

Javier Torrecilla — Mon, 14 May 2012 09:24:37 GMT

Introducción:

En este post vamos a ver como utilizar otros tipos de datos numéricos dentro de una enumeración.

Si bien, no es un problema que nos vayamos a encontrar a menudo, pero que podamos realizarlo si lo necesitamos.

Al lio:

A la hora de definir nuestro enumerado tendremos que indicar uno de los siguientes valores:

- Byte

- SByte

- Short

- UShort

- Long

- ULong

- UInt

Ejemplo:

        1: public enum MyLongEnum  :long    

       2: {

       3:     Value = 1569874585236L

       4: }

Para que posteriormente podamos utilizar dicho valor desde nuestro código será necesario hacer una conversión:

       1: var myValue = (long)MyLongEnum.Value;

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!

WinRT: Establecer un estilo Condicional #Metro #Win8

Javier Torrecilla — Wed, 25 Apr 2012 11:36:23 GMT

Introducción

Estoy realizando una pequeña app para Windows8 con WinRT y Metro.

Pese a que no soy ningun experto en WPF, creo que condicionar el estilo a un elemento de Binding era algo trivial en WPF o Silverlight, en WinRT, (espero que de momento) no lo es.

Solución que hemos hablado por Twitter

En una conversación mantenida con @Antiocool y con @CorsarioVasco, hablabamos de definir 2 bloques de texto, uno para cada estilo (puesto que el condicional era para un booleano) y cada uno tuviera el estilo correspondiente. Y jugar con la visibilidad del segundo con respecto de la visibilidad del primero. Pese a que es un poco “BADSMELL”, de momento es la “única” solución rápida que he encontrado.

1) Partiendo de un Converter BooleanToVisibility

        1: public class BooleanToVisibilityConverter : IValueConverter 

       2:  {

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

       4:      {

       5:          bool val = (bool)value;

       6:          return (val ? Visibility.Visible : Visibility.Collapsed);

       7:            

       8:      }

       9:  

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

      11:      {

      12:          var val = (Visibility)value;

      13:          return (val == Visibility.Visible);

      14:      }

      15:  }

2) Definiremos un Visibility Inverter Converter:

       1: public class VisibilityInverterConverter : IValueConverter 

       2:     {

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

       4:         {

       5:             return ((Visibility)value == Visibility.Visible ? Visibility.Collapsed : Visibility.Visible);

       6:         }

       7:  

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

       9:         {

      10:             return ((Visibility)value == Visibility.Visible ? Visibility.Collapsed : Visibility.Visible);

      11:         }

      12:     }

3) Escribiremos el xaml necesario para utilizarlo:

3.1) Definimos los converters como recursos:

       1: <UserControl.Resources>

       2:        

       3:        <!-- TODO: Delete this line if the key AppName is declared in App.xaml -->

       4:        <converters:BooleanToVisibilityConverter x:Name="BooleanConverter"/>

       5:        <converters:VisibilityInverterConverter x:Name="VisibilityConverter"/>

       6:    </UserControl.Resources>

       7: </UserControl.Resources>

3.2) Definimos los bindings necesarios:

       1: <TextBlock x:Name="tName" 

       2:     Text="{Binding Child.Name}" 

       3:     Visibility="{Binding Child.Gender,

       4:                 Converter={StaticResource BooleanConverter}}" 

       5:                 Grid.Row="0" Grid.ColumnSpan="3" 

       6:                 Style="{StaticResource ChildNameStyle}" d:LayoutOverrides="Margin"/>

       7: <TextBlock Text="{Binding Child.Name}" 

       8:             Visibility="{Binding ElementName=tName, 

       9:             Path=Visibility,Converter={StaticResource VisibilityConverter}}"

      10:              Grid.Row="0" Grid.ColumnSpan="3" 

      11:             Style="{StaticResource ChildNameStyleGirl}" d:LayoutOverrides="Margin"/>

      12:

Como se puede observar cada TextBlock tiene el mismo texto asignado, y cambia el estilo.

La propiedad Visivility del segundo TextBlock está asignada a la misma propiedad del primer TextBlock aplicando el converter que hemos definido previamente.

Espero que os sea de utilidad y/o si conoceis otra alternativa, por favor comentarla!.

Saludos!!

Win8: Serializar y Deserializar con WinRT C#

Javier Torrecilla — Mon, 23 Apr 2012 10:49:19 GMT

Introducción

En este breve post vamos a ver como llevar a cabo la serialización de objetos dentro de una aplicación metro con WinRT y C#.

Código

Partiendo de una clase tipo:

        1: public class Employee

       2: {

       3:     public int Id { get; set; }

       4:     public string FirstName { get; set; }

       5:     public string LastName { get; set; }

       6:     public DateTime BirthDate { get; set; }

       7: }

Serializando un objeto:

       1: Employee obj;

       2: using (var fileStream = await ApplicationData.Current.RoamingFolder.OpenStreamForWriteAsync(String.Format("ci{0}{1}.xml",

       3:  obj.LastName, obj.FirstName), 

       4:                     CreationCollisionOption.ReplaceExisting))

       5:                 {

       6:                     var serializer = new XmlSerializer(typeof(ChildInfo));

       7:                     serializer.Serialize(fileStream, obj);

       8:                 }

Deserializando un objeto:

       1: Employee obj;

       2: sing(var fileStream = await ApplicationData.Current.RoamingFolder.OpenStreamForReadAsync(root))

       3:  

       4:    XmlSerializer serializer=new XmlSerializer(typeof(Employee));

       5:    obj = (Employee)serializer.Deserialize(fileStream);

Espero que os sirva.

Saludos!

MVC: Trabajando con campos con etiquetas HTML

Javier Torrecilla — Tue, 10 Apr 2012 11:54:43 GMT

Introducción:

En este post vamos a ver como trabajar con un modelo donde una de nuestras propiedades va a almacenar valores de tipo HTML, como por ejemplo el contenido del post de un blog:

        1: <p>Este el texto del post, con un enlace <a href='http://bing.com'>bing</a></p>

Abordando el problema:

Partiendo de un modelo sencillo:

       1: public class Post

       2: {

       3:     public Guid ID { get; set; }

       4:     public string Title { get; set; }

       5:     public string Content { get; set; }

       6: }

donde nuestra propiedad “Content” va a ser la que va almacenar el código HTML vamos a cualificarla con el atributo AllowHtml, para que en el momento de grabar nuestros post desde el explorador, permitirá evitar la validación de dicho campo sin tener que comprobar las etiquetas HTML introducidas en él.

Posteriormente para poder visualizar nuestro HTML con el formato HTML, vamos a hacer uso del método Raw del Helper HTML, por lo que el contenido de nuestra vista quedaría:

       1: @foreach (var c in Model)

       2: {

       3:     <article>

       4:         <h1>@c.Title</h1>

       5:         @Html.Raw(@c.Content)

       6:     </article> 

       7: }

Espero que os sea de utilidad.

Saludos!!

Convertir un IEnumerable a DataTable

Javier Torrecilla — Wed, 04 Apr 2012 10:15:35 GMT

Introducción

En este post vamos a ver como llevar a cabo la exportación de un objeto IEnumerable<T> a un DataTable. Pero, espera!!! Ya existe un método extensor CopyToDataTable, que parece realizar esta acción.

Todo parece que sí, pero parece demasiado bonito. Si nos fijamos en la firma del método:

        1: public static DataTable CopyToDataTable<T>(

       2:     this IEnumerable<T> source

       3: )

       4: where T : DataRow

Veremos que este método, solo lo podremos utilizar en el caso de que T sea de tipo DataRow o implemente a DataRow.

Bueno, el porque del post es debido a una preguntaba que lanzó ayer en Twitter @Zpektrum, sobre porque no podía utilizar dicho método con una consulta Linq.

Código:

Para ilustrar el ejemplo vamos a ver una query linq contra un DataTable:

       1: var query = from t in dt1.AsEnumerable()

       2:                         select new

       3:                         {

       4:                             ID = t.Field<string>("ID"),

       5:                             Nombre = t.Field<string>("Name")

       6:                         };

Como podeís apreciar estamos realizando una consulta sobre las filas de la tabla dt1, y escogiendo las columnas ID y Nombre. El resultado de esta consulta va a devolver un IEnumerable<T> donde T va a ser un tipo anónimo, por lo que dicho tipo no va a ser DataRow y no vamos a tener disponible el método CopyToDataTable.

Bien, para construir nuestro nuevo método extensor, tendremos que definir una nueva clase estática y un método estático que retorne un objeto de Tipo DataTable, y haremos que el método sea genérico.

       1: public static class IEnumerableExtensions

       2:     {

       3:         public static DataTable CopyAnonymusToDataTable<T>(this IEnumerable<T> info)

       4:         {

       5:             var type = typeof(T);

       6:             if (type.Equals(typeof(DataRow))) 

       7:                 return (info as IEnumerable<DataRow>).CopyToDataTable();

       8:             DataTable dt = new DataTable();

       9:             DataRow r;

      10:             type.GetProperties().ToList().ForEach(a=>  dt.Columns.Add(a.Name));

      11:             foreach (var c in info)

      12:             {

      13:                 r = dt.NewRow();

      14:                 c.GetType().GetProperties().ToList().ForEach(a => r[a.Name] = a.GetValue(c,null));

      15:                 dt.Rows.Add(r);

      16:             }

      17:             return dt;

      18:         }

      19:         

      20:     }

Para que el método sea un método extensor es necesario que sea estático, que este contenido en una clase estática y que su primer parámetro tenga el modificador “this” y el tipo que va a extender.

Explicando el método:

El método es sencillo, en primer lugar comprobamos que si el tipo de T es DataRow que ejecute el método CopyToDataTable ya existente.

En caso contrario, a través de reflectión obtendremos las propiedades del Tipo T, e iremos definiendo nuevas columnas con el nombre de dichas propiedades en la tabla resultante.

Por último, iteraremos sobre el contenido de la colección e iremos agregando las filas para devolverlos.

Ejecución del método:

Continuando con el ejemplo anterior:

       1: var query = (from t in dt1.AsEnumerable()

       2:                         select new

       3:                         {

       4:                             ID = t.Field<string>("ID"),

       5:                             Nombre = t.Field<string>("Name")

       6:                         }).CopyAnonymusToDataTable();

De está manera query, será de tipo DataTable y ya podremos manejar dicha tabla a nuestro gusto.

Un saludo y espero que os sea de utilidad.

Usando Enumeraciones en Entity Framework 5.0

Javier Torrecilla — Wed, 21 Mar 2012 07:47:03 GMT

Introducción

Es bastante probable que en alguna de las tablas de vuestras bases de datos tengas alguna propiedad de tipo Integer para representar una clave ajena de una tabla que no suele cambiar.

¿Por qué no utilizar una enumeración en lugar de otra tabla en la Base de Datos?

Bien, con Entity Framework 5.0 Beta 1 podemos hacer uso de enumeraciones en nuestras entidades sin tener que hacer ninguna chapuza. Esta versión es para VS11 con .NET 4.5. El trabajo con Enums ya se pudo probar con una CTP que salio en Junio de 2011 con Database First y Model First, pero no con Code First.

En este post vamos a ver como realizarlo en los distintos enfoques existentes.

Database First y Model First

Ya que Database First y Model First son dos enfoques muy similares vamos a tratarlos en común.

Para empezar:

1) Definiremos un nuevo proyecto, por ejemplo: una aplicación de consola.

2) Agregaremos nuestro Entity Data Model indicando nuestra Base de Datos y tablas.

3) Dentro del explorador del modelo de nuestro diagrama, veremos una nueva carpeta “Enum Types”. Pulsaremos con el botón secundario del ratón, y elegiremos la opción “Add Enum Type”. Configuraremos las características: Nombre, tipo de dato, y los miembros:

4) Asignación de la enumeración a una propiedad escalar: Desde la ventana de propiedades

Code First

Para usarlo seguiremos estos pasos:

1) Definiremos nuestra enumeración:

        1: public enum Category

       2: {

       3:     Technology,

       4:     Computer,

       5:     Games

       6: }

2) Definiremos nuestra entidad:

       1: public class Products

       2: {

       3:     public int Id {get;set;}

       4:     public string Name {get;set;}

       5:     public Category Category {get;set;}

       6: }

3) Incluiremos la colección en nuestro contexto:

       1: public class Context : DbContext

       2: {

       3:     public DbSet<Product> Products {get;set;}

       4: }

4) En el momento de la definición de la Base de Datos va a definir una columna llamada Category de tipo Integer en nuestra Base de Datos.

Haciendo Consultas

Como las enumeraciones no estaban soportadas en versiones anteriores para poder utilizar la enumeración teniamos que obtener el código que nos interesaba.

En esta nueva versión podremos realizar la siguiente consulta:

       1: var query = context.Products.Where(a=> a.Category == Category.Games);

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!

WebCast Entity Framework

Javier Torrecilla — Tue, 06 Mar 2012 14:19:29 GMT

Buenos Tardes,

El viernes pasado iba a realizar un evento online acerca de Entity Framework, por motivos ajenos a GuseNET no pudimos realizar dicho evento de forma online.

Lo primero a todos los que estabais interesados en verlo, Lo siento!!

Voy a realizarlo como tenia previsto este Viernes 09 de Marzo a las 16:30 hora de Madrid.

El enlace de registro:https://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032508198&Culture=es-ES

Un saludo

[GuseNET] WebCast Entity Framework

Javier Torrecilla — Fri, 24 Feb 2012 11:29:57 GMT

Buenos días,

Hace un tiempo publique un Evento presencial en el que voy a hablar acerca de Entity Framework para el grupo de usuarios GUSNET.

En vista de que varías personas han preguntado si lo ibamos a grabar o si lo ibamos a emitir de alguna manera online, y gracias a la gente de MS, tenemos la posibilidad de emitirlo vía Live Meeting.

La URL de registro del evento: aquí.

Un saludo

[UOC] Materiales WebCast Async y Await

Javier Torrecilla — Fri, 24 Feb 2012 08:02:37 GMT

Buenos días,

Desde este post lo primero que quiero hacer es daros las gracias por asistir a la charla sobre Async y Await que tuve el placer de impartir ayer.

Os dejo los materiales para que los descarguéis y podáis hacer vuestras pruebas.

- Presentación

- Demos

En breve también podréis acceder a la grabación de la misma para aquellos que no pudisteis asistir.

Si tenéis cualquier cosa, no dudéis en enviarme un correo o Tweet.

Un saludo.

PD: Las demos están realizadas con VS11, pero para aquellos que queráis probarlo en VS2010 solo tendréis que descargar Async CTP V3 para VS y podréis probarlo.

[GuseNET] Evento Sobre Entity Framework + Mesa Redonda

Javier Torrecilla — Fri, 17 Feb 2012 09:32:20 GMT

Hoy os quiero anunciar una charla que voy a impartir para el Grupo de Usuarios GUSENET.

La Agenda del Evento es:

16:30 – 19:00: USO Y VENTAJAS DE ENTITY FRAMEWORK 4: ASÍ COMO TRUCOS PARA ENFRENTARSE A CUESTIONES HABITUALES DEL USO DIARIO
19:00 – 20:00: Mesa redonda para debatir reuniones futuras del grupo.

¿Dónde?

Universidad de Murcia, Facultad de Informática

Aula 1.01

El enlace de registro: Aquí

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

[UOC] WebCast sobre Async y Await

Javier Torrecilla — Wed, 08 Feb 2012 10:44:33 GMT

Alex Casquete me preguntó hace un tiempo si me apetecía dar una charlita sobre el nuevo paradigma de programación asíncrona, que se va a introducir con C# 5.0 y que ya podemos probar con VS 11 y la Async CTP 11, ASYNC y AWAIT.

Mi respuesta fue que si :D

Así que se queréis ver de que va todo esto el Jueves 23 de Febrero haré este WebCast en colaboración con UoC Dot Net Club.

Enlace al registro del evento. Registro.

Saludos

ORAPOCO: V2.0

Javier Torrecilla — Wed, 01 Feb 2012 12:03:00 GMT

Introducción

Bueno, como habréis podido notar ando creando un ORM “ligero” para trabajar contra Oracle (Serie ORAPOCO).

Bien, en la segunda actualización, tanto @Eiximenis como @Juanma, me indicaban algo que las clases POCO no debía implementar ninguna clase Base, algo que a mi tampoco me convencía haberlo agregado.

Además de ello Eduard comentaba la posibilidad de hacer configuración de los Mapeos, para evitar hacer uso de Atributos en las clases POCO y que están sean completamente POCO. El tema de los mapeos es parecido a lo que se ve en FluentNhibernate.

Por otro lado @_PedroHurtado, me comentaba que era posible hacer Sql Injection, y me propuso que modificara los parámetros String por Expression.

Bueno por estos motivos nace está nueva versión de ORAPOCO.

Cambios

Modificación de la Plantilla T4

He modificado la plantilla T4, de tal forma que va a generar objetos POCO, sin ningún tipo de atributo:

Objeto POCO:

public class BL_BLOQUEO_PANTALLA

{

public System.Int32 BLPA_ID {get;set;}

public System.String BLPA_PANTALLA {get;set;}

public System.String BLPA_FECHA {get;set;}

public System.String BLPA_HORA {get;set;}

public System.String BLPA_USUARIO {get;set;}

}

Del mismo modo se van a generar unas nuevas clases, que serán los Mapeadores por defecto:

public class BL_BLOQUEO_PANTALLAMapper : GenericMapper<BL_BLOQUEO_PANTALLA>

{

public Type GetMappedType()

{

return typeof(BL_BLOQUEO_PANTALLA);

}

public BL_BLOQUEO_PANTALLAMapper() : base()

{

AddColumnMapping(x=> x.BLPA_ID);

SetPrimaryKeyField(x => x.BLPA_ID);

AddColumnMapping(x=> x.BLPA_PANTALLA);

SetNullable(x=> x.BLPA_PANTALLA);

AddColumnMapping(x=> x.BLPA_FECHA);

SetNullable(x=> x.BLPA_FECHA);

AddColumnMapping(x=> x.BLPA_HORA);

SetNullable(x=> x.BLPA_HORA);

AddColumnMapping(x=> x.BLPA_USUARIO);

SetNullable(x=> x.BLPA_USUARIO);

}

}

Creación de los Objetos OracleColumnInfo,Mapper, IGenericMapper<T> y GenericMapper<T>

Para facilitar el mapeo de datos, he creado las siguientes clases e interfaz:

Clase OraceColumnInfo para representar la información relativa a cada columna de los objetos POCO.

public class OracleColumnInfo

{

public OracleColumnInfo()

{

IsPk = false;

Nullable = false;

}

public bool IsPk { get; set; }

public string ColumnName { get; set; }

public bool Nullable { get; set; }

public string DefaultValue { get; set; }

public string SequenceName { get; set; }

}

La Interfaz IGenericMapper<T>:

public interface IGenericMapper<T>

{

IGenericMapper<T> SetPrimaryKeyField(Expression<Func<T, object>> property);

IGenericMapper<T> AddColumnMapping(Expression<Func<T, object>> property);

IGenericMapper<T> SetNullable(Expression<Func<T, object>> property);

IGenericMapper<T> SetDefaultValue(Expression<Func<T, object>> property, string DefaultValue);

IGenericMapper<T> SetSequence(Expression<Func<T, object>> property, string SequenceName);

}

La clase Mapper: Va a servir para representar el conjunto de columnas de un objeto POCO.

La clase: GenericMapper<T>, va a extender a Mapper e implementar a IGenericMapper:

public class GenericMapper<T> : Mapper,IGenericMapper<T>

{

public GenericMapper()

{

Columns = new List<OracleColumnInfo>();

}

 

public IGenericMapper<T> AddColumnMapping(Expression<Func<T, object>> property)

{

PropertyInfo propertyInfo = GetProperty(property);

return this;

}



public IGenericMapper<T> SetPrimaryKeyField(Expression<Func<T, object>> property)

{

PropertyInfo propertyInfo = GetProperty(property);

AddColumn(propertyInfo);

Columns.Where(col => col.ColumnName.Equals(propertyInfo.Name)).FirstOrDefault().IsPk = true;

return this;

}



public IGenericMapper<T> SetNullable(Expression<Func<T, object>> property)

{

PropertyInfo propertyInfo = GetProperty(property);

AddColumn(propertyInfo);

Columns.Where(col => col.ColumnName.Equals(propertyInfo.Name)).FirstOrDefault().Nullable = true;

return this;

}

public IGenericMapper<T> SetDefaultValue(Expression<Func<T, object>> property, string DefaultValue)

{

PropertyInfo propertyInfo = GetProperty(property);

AddColumn(propertyInfo);

Columns.Where(col => col.ColumnName.Equals(propertyInfo.Name)).FirstOrDefault().DefaultValue = DefaultValue;

return this;

}

 

private void AddColumn(PropertyInfo propertyInfo)

{

var column = Columns.Where(col => col.ColumnName.Equals(propertyInfo.Name)).FirstOrDefault();

if (column == null)

Columns.Add(new OracleColumnInfo { ColumnName = propertyInfo.Name });

}

private static PropertyInfo GetProperty(Expression<Func<T, object>> property)

{

PropertyInfo propertyInfo = null;

if (property.Body is MemberExpression)

{

propertyInfo = (property.Body as MemberExpression).Member as PropertyInfo;

}

else

{

propertyInfo = (((UnaryExpression)property.Body).Operand as MemberExpression).Member as PropertyInfo;

}

 

return propertyInfo;

}



public IGenericMapper<T> SetSequence(Expression<Func<T, object>> property, string SequenceName)

{

PropertyInfo propertyInfo = GetProperty(property);

AddColumn(propertyInfo);

Columns.Where(col => col.ColumnName.Equals(propertyInfo.Name)).FirstOrDefault().SequenceName = SequenceName;

return this;

}



}

Creación de ConfigureMapping y AutoConfigureMapping

Ambos métodos van a servir para configurar los Mapeos, y serán invocados de forma Manual.

AutoConfigureMapping, va a registrar todas aquellas clases que Implementen AutoConfigureMapping dentro del Assembly en el que nos encontremos.

Código:

Primer Ejemplo: Como crear y registrar un nuevo Mapeo:

db.ConfigureMapping<SAMPLE>(new GenericMapper<SAMPLE>().

SetPrimaryKeyField(x => x.ID).

AddColumnMapping(x => x.NOMBRE).

SetDefaultValue(x => x.ID, "SysGuid()"));

El Mapeo permite llevar a cabo:

- Creación de columnas.

- Establecer PK Simple o Compuesta.

- Establecer Valor Por Defecto.

- Establecer Nulos.

- Establecer Secuencias.

A la hora de realizar una inserción, actualización o borrado, se va a comprobar si existe un mapeo Configurado, en caso de no existir se intentará ejecutar como si tuviese Atributos.

Nuevas formas de Ejecutar Consultas:

Al haber sustituido string por Expression, se ejecutarán las consultas del siguiente modo:

var data = db.Query<EMPRESA>(columns:

(x) => new { x.EMPR_NOMBRE_CORTO, x.EMPR_NOMBRE_EMPRESA },

where:

(x => ( x.EMPR_NOMBRE_EMPRESA.Contains("D") ||

x.EMPR_CODIGO_EMPRESA != 101 ||

x.EMPR_AÑO >= 2008 ) && (

x.EMPR_MES == 1 )));

Los valores esperados para los parámetros “Columns”, “Where” y “Order”, van a ser expresiones lambda.

Finally

Bien como siempre tenéis las descargas en:

- GitHub

- Nuget

Y como siempre cualquier feedback será bien recibido.

ORAPOCO: Update 2

Javier Torrecilla — Mon, 30 Jan 2012 10:03:00 GMT

Introducción

Hace unos días publique ORAPOCO, un ORM ligero para trabajar con Bases de Datos Oracle, y su primera actualización

Cambios y Mejoras

- He realizado un poco de refactoring en el código.

- He creado una clase abstracta “Base” que va a servir como Base de nuestras Entidades.

- He añadido una propiedad para indicar el modo de ejecución de los comandos: Normal(Valor por defecto) o UnitOfWork.

- He modificado la plantilla, para dar la posibilidad de utilizar el atributo “DefaultValue” con los valores por defecto de la Base de Datos.

Ejemplos:

Las nuevas entidades generadas por la plantilla tendrán un aspecto similar a:

public class SAMPLE : Base

   {

       [IsPK()]

       [DefaultValue("SYS_GUID()")]

       public System.Guid ID { get; set; }

  

  

       public System.String NOMBRE { get; set; }

  

   }

Un ejemplo de utilización de UoW:

var db = new POCO.Ora.TP.OracleDB("MyDB",POCO.Ora.TP.Enums.Mode.UnitOfWork);

var sample = new POCO.Ora.TP.SAMPLE { NOMBRE = "Javier" };

db.Insert<POCO.Ora.TP.SAMPLE>(sample);

db.Insert<POCO.Ora.TP.SAMPLE>(new POCO.Ora.TP.SAMPLE { NOMBRE = "Alvaro" });

db.Save();

Descargas:

Como siempre tenéis las descargas en:

- GitHub

- Nuget

Y proximamente en CodePlex.

Saludos, y como siempre si me dais FeedBack Genial!

ORAPOCO: Primera actualización

Javier Torrecilla — Mon, 23 Jan 2012 12:21:00 GMT

Introducción

Hace unos días publique ORAPOCO, y hoy lanzo una nueva versión con algunas features y modificaciones.

Lo nuevo

Modificaciones:

- Modificación en el atributo IsPK: Tal como comentaba Eduard en el post anterior realmente no es necesario indicar True en dicho atributo puesto que solo lo van a tener los campos que formen la PK.

- Refactorización de los métodos de Inserción, Actualización y Borrado.

Mejoras:

- Creación del atributo Sequence:

internal class SequenceAttribute : System.Attribute 

{

    public SequenceAttribute(string sequenceName)

    {

        if (string.IsNullOrWhiteSpace(sequenceName)) throw new Exception("Sequence name is necessary.");

        SequenceName = sequenceName;

    }

  

    public string SequenceName { get; set; }

}

Este atributo, que se agregará de forma manual a nuestras entidades nos va a permitir simular el uso de auto numéricos en Oracle a través de una Secuencia.

Ejemplo de uso:

public class TM_EMPRESAS

{

    [IsPK()]

    [Sequence("S_Empresas")]

    public System.Int16 EMPR_CODIGO_EMPRESA {get;set;}       

    public System.String EMPR_NOMBRE_EMPRESA {get;set;}       

///...

}

De esta manera a la hora de ejecutar la sentencia utilizará el siguiente valor auto numérico de la secuencia indicada.

Descargas:

- GitHub

- Nuget

Saludos!

[ORM]ORAPOCO: Trabajando contra Oracle

Javier Torrecilla — Wed, 18 Jan 2012 09:25:00 GMT

Introducción El objeto de este post, es hablar de un pequeño proyecto que acabo de publicar: ORAPOCO. Podéis encontrarlo tanto en GITHUB como en Nuget . ¿Qué es ORAPOCO? Es un pequeño proyecto que va a permitir trabajar con objetos POCO y contra nuestra Base de Datos Oracle. El proyecto consta de los siguientes ficheros: - OracleDB.cs: Esta clase va a ser la encargada de llevar a cabo todas las acciones contra la Base de Datos. Los métodos disponibles...(read more)

Comparativa ORM-Lite, EF y ADO.NET

Javier Torrecilla — Thu, 12 Jan 2012 11:06:00 GMT

Introducción A raíz de la serie de post que estoy escribiendo acerca de ORMS ligeros con ( Dapper , Massive y PetaPoco ), y a pesar de no haber podido meter en la comparativa a Massive (lo intentaré actualizar esta noche), he decidido hacer una pequeña comparativa que me ha parecido interesante. Comparativa Para realizar la comparativa he utilizado los siguientes fragmentos de código, para realizar la inserción de 500 Registros en la misma tabla: Entity Framework 1: private static void UsingEF_B...(read more)