EF 4 + CTP 5 = Code First : Database III

Este es el tercero y último post dedicado a la creación y uso de las bases de datos en EF 4 + CTP 5, puede revisar las dos entradas anteriores, I y II, si desea recordar lo tratado en las mismas. En esta ocasión, trataremos de mostrar los inicializadores.

La clase DbDatabase, comentada ya en el anterior blog, además de elementos para establecer la factoria a utilizar y distintos métodos de ayuda nos permite establecer distintas estrategias de inicialización de nuestras bases de datos, de tal forma, que antes de crearlas o utilizarlas podamos escribir algunos pasos. Estas estrategias de inicialización pueden asignarse mediante el uso del método SetInitializer, el cual, como vemos a continuación, nos permite establecer una estrategia, definida por un contrato llamado IDatabaseInitializer<TContext>.

<span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">void</span> SetInitializer&lt;TContext&gt;(IDatabaseInitializer&lt;TContext&gt; strategy)
    <span class="kwrd">where</span> TContext : System.Data.Entity.DbContext;

1 2	<span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">void</span> SetInitializer<TContext>(IDatabaseInitializer<TContext> strategy) <span class="kwrd">where</span> TContext : System.Data.Entity.DbContext;

&#160;

Este contrato de inicialización, como puede verse a continuación en un ejemplo de implementación custom, únicamente define un método, InitializeDatabase, en el cual podremos colocar el código de inicialización que necesitemos.

<span class="kwrd">public</span> <span class="kwrd">class</span> CustomStrategy&lt;TContext&gt;
        :IDatabaseInitializer&lt;TContext&gt;
        <span class="kwrd">where</span> TContext:DbContext
{
        <span class="kwrd">public</span> <span class="kwrd">void</span> InitializeDatabase(TContext context)
        {
            <span class="kwrd">throw</span> <span class="kwrd">new</span> NotImplementedException();
        }
}

public class CustomStrategy<TContext>

:IDatabaseInitializer<TContext>

where TContext:DbContext

{

public void InitializeDatabase(TContext context)

{

throw new NotImplementedException();

}

Estas estrategias de inicialización, como seguramente ya sabrá, son utilizadas por ellos para la generación del esquema de la base de datos o la actualización de la misma. Dentro del espacio de nombres System.Data.Entity.Database podemos encontrar las tres estrategias siguientes:

CreateDatabaseIfNotExist<TContext>
DropCreateDatabaseAlways<TContext>
DropCreateDatabaseIfModelChanges<TContext>

Los nombres de las estrategias creo que son bastante descriptivos, por lo tanto no necesitan explicación. A continuación, en las siguientes lineas de código podemos ver como realizar la inicialización de una estrategia, por defecto no hay ninguna asignada, aunque en la documentación se sugiera que está DropCreateDatabaseIfModelChanges.

<span class="kwrd">using</span> (CustomerContext context = <span class="kwrd">new</span> CustomerContext())
{
   DbDatabase.SetInitializer&lt;CustomerContext&gt;(<span class="kwrd">new</span> CreateDatabaseIfNotExists&lt;CustomerContext&gt;());
}

using (CustomerContext context = new CustomerContext())

{

DbDatabase.SetInitializer<CustomerContext>(new CreateDatabaseIfNotExists<CustomerContext>());

}

Buceando en el código con Reflector, una de las primeras cosas que suelo hacer siempre cuando reviso una CTP o versión preliminar, de los que la documentación es escasa, se puede ver como siempre que se asigna un elemento DbDatabase, del que ya hemos hablado, se busca en la configuración de la aplicación los inicializadores que queremos.

El código en concreto es el siguiente:

<span class="kwrd">public</span> <span class="kwrd">static</span> <span class="kwrd">void</span> ApplyInitializersFromConfig()
{
    <span class="kwrd">string</span>[] allKeys = ConfigurationManager.AppSettings.AllKeys;
    <span class="kwrd">if</span> (allKeys != <span class="kwrd">null</span>)
    {
        <span class="kwrd">foreach</span> (DatabaseInitializerConfig config <span class="kwrd">in</span> allKeys.Where&lt;<span class="kwrd">string</span>&gt;(<span class="kwrd">delegate</span> (<span class="kwrd">string</span> k) {
            <span class="kwrd">return</span> k.StartsWith(<span class="str">&quot;DatabaseInitializerForType&quot;</span>, StringComparison.OrdinalIgnoreCase);
        }).Select&lt;<span class="kwrd">string</span>, DatabaseInitializerConfig&gt;(<span class="kwrd">delegate</span> (<span class="kwrd">string</span> k) {
            <span class="kwrd">return</span> <span class="kwrd">new</span> DatabaseInitializerConfig(k, ConfigurationManager.AppSettings[k]);
        }))
        {
            config.ApplyInitializer();
        }
    }
}

public static void ApplyInitializersFromConfig()

{

string[] allKeys = ConfigurationManager.AppSettings.AllKeys;

if (allKeys != null)

{

foreach (DatabaseInitializerConfig config in allKeys.Where<string>(delegate (string k) {

return k.StartsWith("DatabaseInitializerForType", StringComparison.OrdinalIgnoreCase);

}).Select<string, DatabaseInitializerConfig>(delegate (string k) {

return new DatabaseInitializerConfig(k, ConfigurationManager.AppSettings[k]);

}))

{

config.ApplyInitializer();

}

De este código uno puede extraer el formato de la especificación en configuración, personalmente lo veo demasiado ofuscado, tanto el formato como la forma de disponerlo en configuración, no obstante, me imagino que será una de las cosas que cambien. Con el fin de mostrar un ejemplo de un inicializador en configuración, las siguientes lineas muestran como asignar un inicializador de nombre CustomStrategy a un contexto de nombre CustomerContext.

&lt;appSettings&gt;
    &lt;add key=<span class="str">&quot;DatabaseInitializerForTypeDatabaseNamingSample.CustomerContext,DatabaseNamingSample&quot;</span>                     
<span class="kwrd">value</span>=<span class="str">&quot;DatabaseNamingSample.CustomStrategy,DatabaseNamingSample&quot;</span>/&gt;
  &lt;/appSettings&gt;

<add key="DatabaseInitializerForTypeDatabaseNamingSample.CustomerContext,DatabaseNamingSample"

value="DatabaseNamingSample.CustomStrategy,DatabaseNamingSample"/>

</appSettings>

Con esta tercera entrega hemos dado una vuelta a todo lo que se refiere creación/uso de bases de datos con respecto a EF 4 + CTP 5. En los siguientes post a vanzaremos en temas como el mapeo de las entidades y las convenciones.

Saludos

Unai

Deja un comentario Cancelar respuesta