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