El blog de Javier Torrecilla : EF

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!

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

[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

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)

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

Lanzamiento Oficial Driver Oracle para Entity Framework

Javier Torrecilla — Fri, 30 Dec 2011 08:09:46 GMT

Anteriormente en el blog ya os había hablado de las Betas publicas que iba liberando Oracle (I,II y III).

Bueno, ~~creo que después de que le hayan pitado los oidos,~~ ayer 29 de diciembre Oracle ha hecho el lanzamiento de la (primera) versión final de su driver para trabajar con Entity Framework para Oracle.

Lista de Descargas:

- 32-bit ODAC with Oracle Developer Tools for Visual Studio (Necesario para 32 y 64 bits)

- 32-bit ODAC xcopy

- x64 ODAC installer and xcopy

Para ver la documentación, la podeis ver y descargar desde aquí.

Algunas novedades a destacar:

- Mejora en Mapeo de Datos

- Uso de WCF y OData

- Mejoras en los Binding a Cursores

Para el año nuevo prometo hacer una serie de post en el que hable más en profundidad de esta nueva versión.

Un saludo!!!

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

Javier Torrecilla — Thu, 20 Oct 2011 11:25:05 GMT

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

[EF + ORACLE] Procedimientos almacenados EF 4.1 y la Beta 2 de Oracle

Javier Torrecilla — Tue, 02 Aug 2011 12:09:45 GMT

Introducción

Hace un tiempo realice una serie de post acerca de usar Oracle con EF, y hace un mes os hable de la salida de la Beta 2 del Driver de Oracle para EF.

En este post vamos a ver como utilizar Procedimientos Almacenados de Oracle desde Entity Framework.

Usando Procedimientos

Partiendo del procedimiento:

        1: PROCEDURE "PROCEDURE1" (

       2:   "COCHE" OUT  SYS_RefCursor) IS

       3: BEGIN 

       4: open COCHE FOR SELECT id_coche,nombre,marca FROM COCHES;

       5:  

       6: END;

Donde vamos a devolver un cursor con toda la información de la Tabla Coches. El procedimiento compila y funciona de forma correcta.

Para poder hacer funcionar el procedimiento, y antes de agregarlo a nuestro modelo, será necesario realizar los siguientes pasos:

1) Agregar la referencia a “Oracle.DataAccess.Client”.

2) Configurar el fichero de Configuración para definir el Cursor:

Dentro del fichero de configuración vamos a definir una sección “oracle.dataaccess.client”:

       1: <oracle.dataaccess.client>

       2:   <settings>

       3:     <add name="JTorrecilla.Procedure1.RefCursor.Coche" value="implicitRefCursor bindinfo='mode=Output'" />

       4:     <add name="JTorrecilla.Procedure1.RefCursorMetaData.Coche.0" 

       5:     value="implicitRefCursor metadata='ColumnName=ID_COCHE;BaseColumnName=ID_COCHE; 

       6:            BaseTableName=COCHES;NATIVE_DATA_TYPE=number;ProviderType=Decimal;PROVIDER_DB_TYPE=Decimal; 

       7:            DataType=System.Decimal;ColumnSize=8;AllowDbNull=False'" />

       8:     <add name="JTorrecilla.Procedure1.RefCursorMetaData.Coche.1" 

       9:             value="implicitRefCursor metadata='ColumnName=NOMBRE;BaseColumnName=NOMBRE;

      10:              BaseTableName=COCHES;NATIVE_DATA_TYPE=Varchar2;ProviderType=Varchar2;

      11:              DataType=System.String;ColumnSize=50'" />

      12:     <add name="JTorrecilla.Procedure1.RefCursorMetaData.Coche.2" 

      13:              value="implicitRefCursor metadata='ColumnName=MARCA;

      14:              BaseColumnName=MARCA;BaseTableName=COCHES;NATIVE_DATA_TYPE=Varchar2;

      15:              ProviderType=Varchar2;DataType=System.String;ColumnSize=50'" />

      16:   </settings>

      17: </oracle.dataaccess.client>

Hemos añadido 4 lineas: la primera define el nombre del cursor y el modo de enlace. Las otras entradas, definen cada una de las columnas que se utilizan en el cursor, así como los tipos de datos y su mapeo dentro de .NET.

Las características que se pueden definir son:

- Nombre de la Columna (ColumnName)

- Tipo de datos nativo en Oracle (Native_Data_Type)

- Tipo de datos del proveedor Oracle (ProviderType)

- Tipo de datos de BD del proveedor(ProviderDBType)

-Tipo de Dato soportado por .NET (DataType)

- Tamaño (ColumnSize)

- Precision (NumericPrecision) y Escala (NumericScale)

- Admisión de Nulos (AllowDBNull)

Una vez configurado el Cursor, vamos a importarlo dentro de nuestro modelo de datos en EF:

Abriremos el explorador del modelo, y desplegaremos los Procedimientos almacenados:

Con el botón secundario sobre “Procedure1” mostraremos el menú contextual y seleccionaremos la opción “Add Function Import”.

Con ello se abrirá un asistente donde elegiremos el Procedimiento que queremos importar, podremos indicar como querremos llamar a la función dentro de nuestro código y nos permitirá ver la información que hemos definido en el fichero de configuración tras presionar el botón “Get Column Info”

En este ejemplo, en el que el resultado del procedimiento devuelve un tipo “Coches” podemos definir que el procedimiento devuelve una colección de ese tipo.

En el caso de que el resultado no se corresponda con una de nuestras entidades, tenemos la posibilidad de definir un nuevo tipo de datos complejo a través del botón “Create New Complex Type”.

Para consumir este procedimiento bastaría con ejecutar el siguiente código:

       1: var coches = ent.PROCEDURE1();

       2: foreach (var c in coches)

       3:                 MessageBox.Show(c.MARCA);

Espero que os sea de utilidad.

Bibliografía:

Readme Beta 2 de Oracle

Beta 2 Driver Oracle para EF y LINQ

Javier Torrecilla — Tue, 05 Jul 2011 10:36:36 GMT

Consultando el apartado de .NET de la página de Oracle, he visto que han publicado la Beta 2 del Driver para trabajar contra Entity Framework y Linq To Entities.

¿Qué incluye esta versión?

- Soporte para el SP1 de VS 2010.

- Mejoras en el mapeo de los tipos de datos de Oracle.

- Corrección de algunos Bugs que podéis ver en el Release Notes

Desde Oracle indican que planean lanzar la versión final durante el último Cuarto de 2011. (Esperemos :D)

Podéis descargar esta beta desde aquí.

Saludos.

[SL] Acceder a una Base de Datos desde Silverlight

Javier Torrecilla — Tue, 07 Jun 2011 13:07:25 GMT

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

Introducción

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

Primer Paso:

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

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

Segundo Paso:

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

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

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

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

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

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

Tercer Paso:

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

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

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

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

        1: <httpModules>

       2:   <add name="DomainServiceModule" 

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

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

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

       6: </httpModules>

Después agregaremos el siguiente fragmento:

       1: <system.serviceModel>

       2:   <serviceHostingEnvironment aspNetCompatibilityEnabled="true" 

       3:     multipleSiteBindingsEnabled="true" />

       4: </system.serviceModel>

También agregaremos la cadena de conexión a la Base de Datos, tal cual la ha creado el modelo de EF.
Por ultimo dentro del proyecto Web agregaremos una referencia al proyecto Server.Servicio.

Mostrando Datos

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

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

       2:             <ListBox.ItemTemplate>

       3:                 <DataTemplate>

       4:                     <Grid>

       5:                         <Grid.ColumnDefinitions>

       6:                             <ColumnDefinition/>

       7:                             <ColumnDefinition/>

       8:                         </Grid.ColumnDefinitions>

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

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

      11:                     </Grid>

      12:                 </DataTemplate>

      13:             </ListBox.ItemTemplate>            

      14:         </ListBox>

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

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

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

       3: listadoCategorias.ItemsSource = context.Categories;

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

Espero que os sea de utilidad.

Saludos.

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

[EF] Ampliar la plantilla por defecto

Javier Torrecilla — Fri, 06 May 2011 10:20:25 GMT

Aunque tengo algunos post pendientes acerca de mi serie de EF, esta semana he podido sacar un rato para este post que creo que puede resultar interesante.

Objetivo

Lo que planteo es ampliar el código definido en la plantilla T4 que se utiliza al generar los objetos de Entity Framework:

Comenzando

Hasta el momento, en todos los post que he escrito, estaba utilizando el modelo estándar, así que voy a explicar como dejar de utilizar esa plantilla para utilizar otra distinta:

-> Pulsamos, dentro del diseñador de nuestro modelo, con el botón secundario del ratón:

-> En el menú, elegiremos la opción Add Códe Generation Item. A continuación aparecerá el siguiente cuadro de dialogo:

En dicho cuadro, elegiremos la Opción “ADO .NET EntityObject Generator” y presionaremos Add.

La Plantilla

Dentro de nuestro proyecto de Visual Studio se habrá añadido un fichero con la extensión TT. Este tipo de ficheros son Plantillas de Generación de Código T4.

Esta plantilla va a contener el código necesario para generar la estructura del contexto y de las entidades de nuestro modelo, así como las relaciones entre las mismas.

Si revisáis el enlace al que hago referencia, explico como incrustar bloques de texto, bloques de código y funciones, por ello no voy a entrar a definirlo.

Modificando la Plantilla

Lo que me gustaría añadir a la plantilla es una forma de garantizar que las propiedades del objeto que no admiten valores Nulos, no tienen un valor nulo, antes de intentar Agregarlo al conjunto de datos al que hacen referencia.

Para lograrlo, vamos a hacer uso de “Reflection” y de un método extensor que agregará funcionalidad a los objetos de tipo “EntityObject”.

Paso 1:

Localizar dentro de la Plantilla “.tt”, la sección donde se escriben los “using / imports” y agregar la referencia al namespace “System.Reflection”

        1: using System.Reflection;

Paso 2:

Definir el método extensor dentro del NameSpace que se va a generar dentro de la plantilla. Para poder localizarlo, podremos buscar dentro de la plantilla el literal “namespace <#=namespaceName#>”.

       1: public static class EntityExtensions

       2: {

       3:     public static bool CheckNullableValues(this EntityObject entity)

       4:     {

       5:         bool retValue = true;

       6:         foreach (PropertyInfo p in entity.GetType().GetProperties())

       7:         {

       8:             foreach (Attribute atr in p.GetCustomAttributes(true))

       9:             {

      10:                 if (atr.GetType().Equals(typeof(EdmScalarPropertyAttribute)))

      11:                 {

      12:                     if (!(atr as EdmScalarPropertyAttribute).IsNullable)

      13:                     {

      14:                         if (p.GetValue(entity, BindingFlags.ExactBinding, null, null, 

      15:                             System.Threading.Thread.CurrentThread.CurrentCulture) == null)

      16:                             return false;

      17:                     }

      18:                 }

      19:  

      20:             }

      21:             

      22:         }

      23:         return retValue;

      24:     }

      25: }

Este método extensor se va a encargar de recorrer las propiedades de la Entidad y comprobar si tiene el atributo “EdmScalarPropertyAttribute” y si su valor es “nullable” es falso.

Paso 3:

Por último, será necesario que encontremos los métodos AddTo, que serán los encargados de agregar las entidades a sus relativos conjuntos.

Para poder encontrar dicho bloque de código, podremos buscar la cadena: “void AddTo<#=set.Name#>”

El código de esa función al momento de definir la plantilla es:

       1: base.AddObject("<#=set.Name#>", <#=parameterName#>);

El código después de modificarlo será:

       1: if (<#=parameterName#>.CheckNullableValues())

       2:             base.AddObject("<#=set.Name#>", <#=parameterName#>);

       3:         else

       4:             throw new Exception(String.Format("Falta rellenar alguna propiedad del objeto {0}",

       5:                                 <#=parameterName#>.ToString()));

Una vez modificado, estos bloques de código, cuando visualicemos el fichero “cs” generado podremos encontrar métodos como el siguiente:

       1: public void AddToCLIENTES(CLIENTES cLIENTES)

       2:         {

       3:             if (cLIENTES.CheckNullableValues())

       4:                 base.AddObject("CLIENTES", cLIENTES);

       5:             else

       6:                 throw new Exception(String.Format("Falta rellenar alguna propiedad del objeto {0}",

       7:                 cLIENTES.ToString()));

       8:         }

Conclusiones

Las plantillas de generación de código nos pueden ayudar a incrementar la funcionalidad de Entity Framework.

Espero que os haya gustado y os motive a investigar las plantillas T4.

Saludos

[EF + Oracle] Consulta de los datos (II)

Javier Torrecilla — Wed, 23 Mar 2011 13:24:12 GMT

Prologo

En el capítulo anterior, realizamos una primera toma de contacto con la consulta de Datos con Linq –To Entities.

Continuación

Al igual que se puede realizar en una consulta SQL, con Linq to Entities disponemos la posibilidad de utilizar la palabra reservada “group”.

Esta sentencia nos va a permitir definir agrupaciones del conjunto de entidades devueltas por nuestra consulta.

Sintaxis SQL:

        1: using (OracleConenction con = new OracleConenction("MyConnection"))

       2: {

       3:     using (OracleCommand cmd=new OracleCommand(@"SELECT ID_PEDIDO,SUM(UNIDADES) 

       4:                                                 FROM DETALLES_PEDIDO

       5:                                                 GROUP BY ID_PEDIDO",con))

       6:     {

       7:  

       8:     }           

       9: }

Sintaxis Linq-EF:

       1: var query = from DETALLE_PEDIDO detalle in context.DETALLE_PEDIDO 

       2:             group detalle by detalle.ID_PEDIDO into g

       3:             select new  {g.Key,Suma = g.Sum(a=>a.UNIDADES)};

En la parte de la select hago uso de la palabra reservada new, para crear un tipo de dato anónimo, con las propiedades que quiero utilizar.

Expresión Lambda:

         1: var query = context.DETALLE_PEDIDO.GroupBy(detalle => detalle.ID_PEDIDO).Select(detalle => 

         2:                 new { 

         3:                     detalle.Key, 

         4:                     Unidades = detalle.Sum(suma => suma.UNIDADES) 

         5:                     }).ToList();

Este ejemplo de agrupación ha sido con una única columna, pero puede darse la situación de tener que agrupar por más de una columna. De nuevo, gracias a los tipos anonimos, podremos logar acometer nuestro objetivo. (El ejemplo es un poco tonto, pero sirve para ver la sintaxis)

Sintaxis SQL:

       1: using (OracleConenction con = new OracleConenction("MyConnection"))

       2: {

       3:      using (OracleCommand cmd = new OracleCommand(@"SELECT ID_PEDIDO,ID_PRODUCTO,SUM(UNIDADES) 

       4:                                                     FROM DETALLES_PEDIDO

       5:                                                     GROUP BY ID_PEDIDO,ID_PRODUCTO", con))

       6:     {

       7:     }

       8: }

Sintaxis Linq-EF:

       1: var query = from DETALLE_PEDIDO detalle in context.DETALLE_PEDIDO 

       2:             group detalle by new {detalle.ID_PEDIDO,detalle.ID_PRODUCTO} into g

       3:             select new { g.Key.ID_PEDIDO,

       4:                          g.Key.ID_PRODUCTO,

       5:                          Suma = g.Sum(suma=>suma.UNIDADES)};

Expresión Lambda:

       1: var query = context.DETALLE_PEDIDO.GroupBy(detalle => new 

       2:             { detalle.ID_PEDIDO, detalle.ID_PRODUCTO }).

       3:             Select(detalle => new

       4:             {

       5:                 detalle.Key.ID_PEDIDO ,

       6:                 detalle.Key.ID_PRODUCTO ,

       7:                 Unidades = detalle.Sum(suma => suma.UNIDADES)

       8:             }).ToList();

En el próximo capítulo veremos la sintaxis necesaria para realizar uniones entre distintas tablas con EF.

[EF + Oracle] Consulta de los datos (I).

Javier Torrecilla — Fri, 18 Mar 2011 08:17:28 GMT

Prologo

Hasta el momento, hemos visto un acercamiento a trabajar con Entity Framework y Oracle viendo:

Durante este y algunos de los siguientes capítulos, vamos a trabajar sobre la consulta de datos con Entity Framework

Introducción a las Consultas de Datos

Por lo general, a la hora de hacer consultas a la Base de Datos, generábamos una clase donde construíamos una o varias sentencias SQL, y a través del los objetos Command, las ejecutábamos contra la conexión existente y devolvíamos los datos en un DataTable o en un DataReader y los utilizábamos como necesitásemos.

Para consultar la BD en Entity Framework, se va a utilizar LINQ – To – Entities. En lugar de construir una sentencia SQL que acceda directamente a la Base de Datos, se va a llevar a cabo una consulta sobre el modelo de Entity Framework en la Entidad (Tabla) sobre la que se desea obtener información.

Internamente, la consulta LINQ que se va a generar va a ser transformada a lenguaje SQL entendible por el motor de Base de Datos, y va a devolver un conjunto de resultados sobre dicha consulta.

En estos posts no voy a entrar a decir como se realiza una consulta SQL, ya que hay mucha información relativa a eso, y en mi propio blog he puesto ya algunos ejemplos.

Creación de una consulta sencilla en EF

El orden de las consultas de EF difiere con respecto de una consulta SQL.

En primer lugar necesitamos definir el Origen de los Datos, es decir, la Entidad que queremos consultar (FROM).

Después, se podrán indicar:

Condiciones de filtrado a través de la palabra reservada Where.
Forma de Agrupación de los datos a través de la palabra Reservada Group by
Forma de Ordenación de los datos a través de la palabra reservada order by.

Y por último, será necesario que indiquemos, a través de la palabra reservada Select, las propiedades que queremos visualizar.

Para ver esto, vamos a hacer un pequeño ejemplo:

Sintaxis SQL:

   1: using (OracleConnection connection=new OracleConnection("MyConnection"))   2: {   3:     using (OracleCommand command =    4:             new OracleCommand("Select * from Empleados",connection))   5:     {   6:         connection.Open();   7:     8:     }   9: }

Sintaxis EF:

   1: var query = from EMPLEADOS employee in ent.EMPLEADOS   2:                         select employee;

Con ambas consultas vamos a obtener el mismo resultado, todos los empleados de la tabla / entidad.

Para realizar esta consulta, realmente no es necesario hacerlo con esta sintaxis de EF, se puede realizar directamente accediendo al ObjectSet Empleados del contexto, obteniendo el mismo resultado.

   1: var query = ent.Empleados;

De la misma manera que en SQL podemos realizar filtrado de registros a visualizar a través de la palabra reservada Where, en EF también podemos utilizarlo:

Sintaxis SQL:

   1: using (OracleConnection connection = new OracleConnection("MyConnection"))   2: {   3:     using (OracleCommand command =   4:       new OracleCommand("select * from empleados where nombre like '%j%'", connection))   5:      {   6:          connection.Open();   7:      }   8: }

Sintaxis EF:

   1: var query = from Empleados emp in ent.Empleados   2: where emp.Nombre.Contains("c")   3: select emp;

Expresión Lambda (Método Extensor Where)

   1: var query = ent.Empleados.Where(empleado => empleado.Nombre.Contains("c"));

En los próximos capítulos vamos a entrar más en profundidad en la consulta de Datos utilizando Linq-To-Entities, viendo las palabras reservadas que nos falta.

EF, Oracle y SP1 de VS2010

Javier Torrecilla — Wed, 16 Mar 2011 11:20:48 GMT

Este es un post cortito, para informar algo que me ha parecido curioso y que he visto en la web de Oracle.

Si tenéis Visual Studio 2010, y estáis trasteando con Entity Framework para Oracle con el driver ODP.NET, si instaláis el SP1, os vais a encontrar con esto:

Al crear o editar un modelo de Entity Framework el IDE se queda colgado.

Fuente: http://www.oracle.com/technetwork/topics/dotnet/tech-info/default-338300.html#mozTocId468690

[EF + Oracle] Actualización y Borrado de Datos

Javier Torrecilla — Tue, 08 Mar 2011 12:55:34 GMT

Prologo

En los capítulos anteriores hemos visto como insertar datos a través de EF, sin secuencias y posteriormente con secuencias. En este capitulo vamos a hablar de la actualización y el borrado de datos.

Actualización de Datos

La modificación de los datos asociados (propiedades) de una Entidad, es una operación muy común y sencilla.

Antes de llevar a cabo la modificación de los valores de una Entidad, podemos determinar el estado de la misma, y observaremos que EntityState tiene un valor EntityState.Unchanged.

Para modificar los datos basta con modificar una Entidad existente. En el ejemplo utilizo un método “ObtenerEmpleadoAModificar(2)” que me va a devolver un empleado válido:

        1: EMPLEADOS emp=ObtenerEmpleadoAModificar(2);

       2: emp.NOMBRE="a";

       3: emp.TELEFONO="2";

       4: emp.EMAIL="aa";

Una vez realizadas todas las modificaciones de un empleado, vamos a volver a comprobar el valor de EntityState, en este caso va a tener el valor EntityState.Modified.

Para persistir estos cambios a la Base de Datos, vamos a invocar a la función SaveChanges, de nuestro contexto.

       1: contexto.SaveChanges();

Si volvemos a revisar la propiedad EntityState, obervaremos que su valor ha pasado a ser EntityState.Unchanged.

Borrado de Datos

Otra operación muy sencilla, es el borrado de una entidad.

El primer paso para poder eliminar una Entidad, es seleccionar la que queremos borrar, e invocar al método DeleteObject del conjunto al que pertenece dicha entidad.

       1: CLIENTES  clienteSeleccionado=ObtenerCliente(15);

       2: contexto.CLIENTES.DeleteObject(clienteSeleccionado);

Antes de invocar a la función la propiedad EntityState va a tener el valor EntityState.Unchanged, y en el momento de la eliminación va a pasar a tener el valor EntityState.Deleted.

Para confirmar el borrado de la Entidad de la base de datos, es necesario como siempre, que invoquemos la función SaveChanges.

Peculiaridades del Borrado

Entity Framework permite tanto actualizaciones como borrados en cascada, aunque las actualizaciones, personalmente no las he visto en muchos sitios.

¿Qué es un Borrado en Cascada?

Un borrado en cascada es una acción que permite la eliminación de los entidades de detalle relacionadas con la Entidad que estamos eliminando.

El borrado en cascada se puede habilitar a la hora de definir las relaciones de la Base de datos.

Gracias al diseñador de Entity Framework, sin necesidad de habilitarlo en la Base de Datos, podemos habilitar el borrado en cascada para una relación determinada.

Ejemplo:

Dada una relación (1-N) Entre clientes y Pedidos

La situación Normal sería no poder eliminar aquellos Clientes, que tengan datos en la Tabla Cabecera_Pedido.

Si seleccionamos la relación (la flecha 1 –> *), y pulsamos con el botón secundario del raton, y propiedades, podremos observar el siguiente listado:

Este listado muestra las propiedades de la relación, indicando la tabla Maestra (Clientes) y la tabla detalle (Cabecera_Pedido).

La propiedad End1 OnDelete nos va a indicar que accion vamos a realizar en el caso de borrar un dato en la tabla Maestra. Existen dos opciones:

- None: No va a realizar ninguna accion en la tabla detalle, por lo tanto si una entidad maestra tiene datos relacionados no se va a poder eliminar.

- Cascade: Va a realizar un borrado de los datos de detalle, antes de realizar el borrado de la Entidad Maestra.

Si habilitamos el borrado en cascada de una relación, e invocamos a la función DeleteObject del conjunto, podremos observar que todas las entidades de Detalle (de la relación indicada) presentan el valor EntityState.Deleted en la propiedad EntityState.

Del mismo modo que en el borrado, inserción o actualización, hasta que no se invoque al método SaveChanges, los cambios no van a ser confirmados en la Base de Datos.

Nota: He explicado el borrado en cascada para que lo conozcáis y sepáis como se utiliza, pero personalmente, a no ser que se traten de errores, no me gusta utilizar el borrado en cascada.

Conclusiones

En este episodio hemos visto como llevar a cabo modificaciones y borrado de entidades, y el borrado en cascada.

En próximos capítulos entraremos a ver las consultas sobre las Entidades, y sobre el propio generador de EF.

[EF + Oracle] Insertando en la Base de Datos (Secuencias) (2/2)

Javier Torrecilla — Thu, 03 Mar 2011 14:27:45 GMT

Prologo

En el episodio anterior hemos visto una forma de crear registros con EF, ahora vamos a ver peculiaridades de ORACLE.

ORACLE

Una característica que posee SQL Server con respecto de Oracle es “Identity”.

Para todos aquellos que no han trabajado con SQL Server, esta propiedad, que aplica a columnas del Tipo Integer permite definirlas como Autoincreméntales, de esa manera se van a rellenar de forma automática, sin tener que especificar la sentencia de inserción a la Base de Datos.

En Entity Framework contra SQL Server, las propiedades que son de este tipo, no se tienen que rellenar tampoco, porque se auto rellenan en SQL Server.

En Oracle, no se dispone directamente de está característica, pero se puede lograr algo parecido.

Secuencias

Las secuencias son objetos de la Base de Datos, que nos permiten generar auto incrementos, pero que no se asocian directamente a una Tabla de la BD.

        1: CREATE SEQUENCE nombre_secuencia

       2: INCREMENT BY numero_incremento 

       3: START WITH numero_por_el_que_empezara 

       4: MAXVALUE valor_maximo | NOMAXVALUE 

       5: MINVALUE valor_minimo | NOMINVALUE 

       6: CYCLE | NOCYCLE 

       7: ORDER | NOORDER

       8:

La sintaxis para definir una secuencia en Oracle es la que se indica arriba, se define con un nombre, un valor mínimo y un valor máximo y el valor en el que empieza.

¿Como se obtiene el valor de la secuencia?

Para poder obtener el próximo valor de la serie, es necesario ejecutar una consulta SQL:

       1: SELECT nb_secuencia.Nextval 

       2: From Dual

Ya que no se puede asociar de forma directa una secuencia a una columna de la Tabla, se puede optar por utilizar un Trigger Antes de la inserción del Registro y ejecutar la sentencia, o, una opción que se me ha ocurrido:

Puesto que el modelo de EF importa solo los objetos de Tipo Tabla o Procedimientos Almacenados / Funciones, he decidido crear un método extensor:

       1: public static class EFSequence 

       2:     {

       3:         public static int GetNextValue(this ObjectContext contexto, string SequenceName) 

       4:         {

       5:             string Connection = ConfigurationManager.ConnectionStrings["JTorrecillaEntities2"].ConnectionString;

       6:             Connection=Connection.Substring(Connection.IndexOf(@"connection string=")+19);

       7:             Connection = Connection.Remove(Connection.Length - 1, 1);

       8:             using (IDbConnection con = new Oracle.DataAccess.Client.OracleConnection(Connection))

       9:             {

      10:                 using (IDbCommand cmd = con.CreateCommand())

      11:                 {

      12:                     con.Open();

      13:                     cmd.CommandText = String.Format("Select {0}.nextval from DUAL", SequenceName);

      14:                     return Convert.ToInt32(cmd.ExecuteScalar());

      15:                 }

      16:             }

      17:  

      18:          }

      19:     }

Este método extensor del ObjectContext, va a realizar la consulta arriba indicada con el nombre de la Secuencia indicada en el parámetro “SequenceName”. Lee la cadena de conexión generada en el fichero de configuración a la hora de crear el modelo de EF, y le quita la información de metadata sobrante. Devolviendo el siguiente valor disponible de la secuencia.

El valor de la secuencia es único, por lo tanto, a la hora de tener usuarios concurrentes al crear nuestras claves con un valor de la secuencia no se van a duplicar.

Esta implementación es propia, es decir, se que hay otras formas y se que no es la más correcta de hacerla, si encuentro una mejor o se me ocurre otra la posteare.

PD: Para poder usar el método extensor, es necesario que en el proyecto referencia a la DLL de Oracle, que encontrareis en el directorio BIN. Escoged la DLL para .NET 4.0

[EF + Oracle] Insertando en la Base de Datos (1/2)

Javier Torrecilla — Thu, 03 Mar 2011 13:29:47 GMT

Prologo

Continuando con la serie de Entity Framework (I ,II y III) en este capítulo vamos a ver como crear registros en la Base de Datos a Través de Entity Framework.

Inserción de Datos

Tal y como hablaba en el 2º post, una entidad se va a corresponder con un registro de la Base de Datos, y cada una de las propiedades con una columna de la Tabla a la que representa la Entidad.

Para comenzar, será necesario que creemos una variable del tipo de Entidad que queremos insertar en la Base de Datos:

        1: EMPLEADOS empleado = new EMPLEADOS();

Como, también comente en el post anterior, existe la posibilidad de utilizar el método estático definido por VS en cada Entidad:

Una vez que hayamos creado el objeto de la entidad, podremos acceder a sus propiedades, para rellenarlas como una clase normal:

       1: empleado.NOMBRE = "Javier Torrecilla";

Después de rellenar las propiedades de nuestra Entidad, será necesario que lo agreguemos al ObjectSet de nuestro ObjectContext:

       1: enti.EMPLEADOS.AddObject(empleado);

       1: enti.AddToEMPLEADOS(empleado);

Ambos métodos van a realizar la misma acción, generar una inserción para la BD.

¿Hemos terminado?

No.

Toda Entidad, posee una propiedad “EntityState”, del tipo enumeración EntityState, que presenta los siguientes tipos:

Detached: Este estado indica que la Entidad ha sido creada, pero no se ha añadido a la base de Datos.
Unchanged: Este estado indica que la Entidad no tiene cambios con respecto de consulta o desde la última vez que se actualizo la BD.
Added: Indica que se ha agregado al ObjectSet, pero todavía no se ha enviado a la Base de Datos.
Deleted: Indica que el objeto se ha borrado del contexto, pero todavía no de la BD.
Modified: Indica que el objeto tiene modificaciones pendientes de guardar en la BD.

Vamos a ver los cambios que se dan en la Propiedad durante los pasos de creación de un Registro y lo vamos a relacionar con su paso a la BD:

Creación de la Entidad y asignación de las propiedades: EntityState=EntityState.Detached;
Agregar el objeto al ObjectSet: La propiedad va a pasar a tener el valor EntityState.Added. Esto todavía no indica que se haya creado el registro en la Base de Datos.
Guardar los Datos:
Para poder guardar los datos en la base de Datos será necesario invocar a la función “SaveChanges()” de nuestro contexto. Una vez invocada la función, el valor de la Propiedad EntityState será EntityState.Unchanged.

¿Qué realiza la función SaveChanges?

Esta función se encarga de sincronizar y enviar todos los cambios pendientes de realizar a la BD.

Se van a agregar, modificar y eliminar todos aquellos Entidades, cuyas propiedad EntityState, tengan un valor Added, Deleted o Modified.

Una vez finalizado el proceso, aquellas entidades con la propiedad en valor Added o Modified, van a pasar a tener un estado “Unchanged”, y aquellas entidades en estado “Deleted”, van a pasar a un estado “Detached”.