[Oracle] Oracle Lanza la Beta 3 del Driver para EF

Aproximadamente tres meses después del lanzamiento de la Beta 2, Oracle ha decidido publicar una nueva Beta de su driver para trabajar con Oracle y Entity Framework, por lo que cada vez parece más cerca el lanzamiento de la versión final.

¿Qué incluye esta nueva BETA?

Esta nueva Beta viene a corregir algunos errores conocidos y algunos cambios sobre cosas existentes.

Bugs Corregidos

– Corrección en la clausula OrderBy que devolvía un orden de filas incorrecto.

– Error de “Access violation” al insertar grandes datos un un CLOB.

– Corrección a la hora de importar funciones que recibían algún parámetro de tipo TimeStamp with TimeZone con dirección OUT / INOUT donde se perdía la información de TimeZone.

– Solventar problema a la hora de definir la precisión y escala para algunos tipos numéricos en las entidades.

– Corrección a la hora de importar funciones que recibían algún parámetro de tipo LONG / LONGRAW con dirección OUT / INOUT se producía una excepción de tipo “memory allocation”.

– Mejora en el rendimiento de la comparación de cadenas en consultas.

Cambios

– A la hora de hacer enlaces de atributos de los cursores: se han cambiado los nombres de los atributos Native_Data_Type y Provider_Db_Type, respectivamente por NativeDataType y ProviderDbType.

– Cambios para obtener de forma correcta la versión de Oracle que se está utilizando.

Notas

Me gustaría recalcar que en las notas de la Release indican que todavía no se da soporte a Code First.

Descargas

Podéis descargar la nueva Beta desde aquí y ver las notas de la Release desde aquí.

 

Saludos

[How To] Comprimir y Descomprimir Ficheros (II)

Introducción

En el post anterior vimos como llevar a cabo la compresión y descompresión de un único fichero a través de la clase GZipStream.

En este post vamos a ver como llevar a cabo la compresión y descompresión de varios ficheros a través de una libreria de terceros, en este caso, Ionic.

Pasos a realizar:

En primer lugar para poder utilizar esta librería es necesario que agreguemos la referencia a la DLL descargada “Ionic.Utils.Zip.dll”.

 

Una vez referenciada la DLL, vamos a crear los métodos necesarios para llevar a cabo los procesos que necesitamos.

Para el correcto funcionamiento de los métodos será necesario, incluir el using al namespace : “Ionic.Utils.Zip”

Ambos métodos los voy a definir dentro de una clase que voy a llamar ZipUtils.

Compresión de Ficheros

Para realizar la compresión de un conjunto de ficheros, primero vamos a necesitar un conjunto de ficheros a comprimir, y después vamos a necesitar una ruta de destino de dicho fichero.

Además de ello, vamos a necesitar el objeto que va a ser el encargado de realizar la compresión de los ficheros, en este caso va a ser un objeto de tipo ZipFile que se encuentra definido en la librería indicada anteriormente.

   1: public static void ComprimirFicheros(List<string> Files, string Zip)

   2:        {

   3:            if (string.IsNullOrWhiteSpace(Zip)) throw new ArgumentNullException("ZipFile", "No se ha especificado la ruta del fichero de destino.");

   4:            if (Files == null) throw new ArgumentNullException("Files", "No se han especificado ficheros a comprimir.");

   5:            if (!Files.Any()) throw new ArgumentNullException("ZipFile", "No se han especificado ficheros a comprimir.");

   6:            using (ZipFile compressZip = new ZipFile(Zip))

   7:            {

   8:                Files.ForEach(a =>

   9:                {

  10:                    if (System.IO.File.GetAttributes(a) == System.IO.FileAttributes.Directory)

  11:                    {

  12:  

  13:                        if (!System.IO.Directory.Exists(a)) throw new Exception(String.Format("El fichero {0} no se ha encontrado.", a));

  14:                        if (System.IO.File.Exists(Zip))

  15:                            compressZip.UpdateDirectory(a);

  16:                        else

  17:                            compressZip.AddDirectory(a);

  18:  

  19:                    }

  20:                    else

  21:                    {

  22:                        if (!System.IO.File.Exists(a)) throw new Exception(String.Format("El fichero {0} no se ha encontrado.", a));

  23:                        if (System.IO.File.Exists(Zip))

  24:                            compressZip.UpdateFile(a);

  25:                        else

  26:                            compressZip.AddFile(a);

  27:                    }

  28:                }

  29:                    );

  30:                compressZip.Save();

  31:            }

 

Para probar este código bastaría con ejecutar el siguiente fragmento de código:

   1: string Fichero = @"c:testingCompresion.zip";

   2: List<string> ficheros = new List<string>();

   3: ficheros.Add(@"C:testdocumento.pdf");

   4: ficheros.Add(@"C:Nueva Carpeta");

   5: try

   6: {

   7:     ZipUtils.ComprimirFicheros(ficheros, Fichero);

   8: }

   9: catch (Exception ex)

  10: {

  11:  

  12:     MessageBox.Show(ex.Message);

  13: }

Descompresión de Ficheros

Para realizar la descompresión de un fichero, primero vamos a necesitar la ruta del fichero a descomprimir, y la ruta donde se va a descomprimir.

   1: public static void DescomprimirFicheros(string Zip,string RutaDestino)

   2: {

   3:     if (string.IsNullOrWhiteSpace(Zip)) throw new ArgumentNullException("ZipFile", "No se ha especificado la ruta del fichero de origen.");

   4:     if (string.IsNullOrWhiteSpace(RutaDestino)) throw new ArgumentNullException("RutaDestino", "No se ha especificado la ruta de destino.");

   5:     if (!System.IO.File.Exists(Zip)) throw new Exception(String.Format("El fichero {0} no se ha encontrado.", Zip));

   6:     if (!System.IO.Directory.Exists(RutaDestino)) throw new Exception(String.Format("La ruta de destino {0} ya existe.", RutaDestino));

   7:     

   8:     using (ZipFile FicheroComprimido = ZipFile.Read(Zip))

   9:     {

  10:                         FicheroComprimido.ExtractAll(RutaDestino);

  11:     }

  12: }

Para probar este código bastaría con ejecutar el siguiente fragmento de código:

   1: string Fichero = @"c:testingCompresion.zip";

   2: try

   3: {

   4:     ZipUtils.DescomprimirFicheros(Fichero, @"c:rutaDestino");

   5: }

   6: catch (Exception ex)

   7: {

   8:  

   9:     MessageBox.Show(ex.Message);

  10: }

Conclusiones

Personalmente pienso que esta librería, nos da mucho juego a la hora de la compresión de distintos ficheros, y pose un buen abanico de posibilidades con las que jugar.

Os invito a que visitéis el conjunto de ejemplos disponibles en Codeplex.

 

Un saludo, y espero que os sea de utilidad.

How To: Utilizar PrincipalPermission para bloquear Funcionalidades

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.

 

   1: string NombreUsuario = ObtenerNombreUsuario();

   2: GenericIdentity identidad = new GenericIdentity(NombreUsuario);

   3: String[] roles = ObtenerRoles(NombreUsuario);

   4: GenericPrincipal MyPrincipal =

   5: new GenericPrincipal(identidad, roles);

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

 

   1: try

   2:            {

   3:                

   4:                PrincipalPermission MyPermission =

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

   6:                // Demand this permission.

   7:                MyPermission.Demand();

   8:                this.DataContext = new ViewModel.Control2();

   9:                

  10:            }

  11:            catch (SecurityException ex)

  12:            {

  13:  

  14:                this.Visibility = Visibility.Hidden; 

  15:            }

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

[Personal] MVP Visual C# 2011

Buenas tardes a todos,

Este post es como dice el titulo para anunciar que he sido galordando por el premio MVP de Microsoft en la categoria de C#.

Desde aquí quiero darles las gracias a los chicos de Microsoft empezando por Cristina Gonzalez, Jose Bonnin, David Salgado, Boris Armenta…

También mi gratitud a la gente de Geeks empezando por Rodrigo Corral por abrirme la cuenta.

Y por ultimo y no menos importante a toda la gente que me lee!

 

Un saludo!