Cadenas de conexión y modelos

  • Artículo

En este tema se explica cómo Entity Framework detecta qué conexión de base de datos se va a usar y cómo puede cambiarla. Los modelos creados con Code First y el Diseñador de EF se tratan en este tema.

Normalmente, una aplicación de Entity Framework usa una clase derivada de DbContext. Esta clase derivada llamará a uno de los constructores de la clase DbContext base para controlar:

  • Cómo se conectará el contexto a una base de datos; es decir, cómo se encuentra o usa una cadena de conexión
  • Si el contexto usará calcular un modelo mediante Code First o cargará un modelo creado con el Diseñador de EF
  • Opciones avanzadas adicionales

Los fragmentos siguientes muestran algunas de las formas en que se pueden usar los constructores de DbContext.

Uso de Code First con conexión por convención

Si no ha realizado ninguna otra configuración en la aplicación, llamar al constructor sin parámetros en DbContext hará que DbContext se ejecute en el modo Code First con una conexión de base de datos creada por convención. Por ejemplo:

namespace Demo.EF
{
    public class BloggingContext : DbContext
    {
        public BloggingContext()
        // C# will call base class parameterless constructor by default
        {
        }
    }
}

En este ejemplo DbContext usa el nombre completo del espacio de nombres de la clase de contexto derivada (Demo.EF.BloggingContext) como nombre de la base de datos y crea una cadena de conexión para esta base de datos mediante SQL Express o LocalDB. Si ambos están instalados, se usará SQL Express.

Visual Studio 2010 incluye SQL Express de forma predeterminada y Visual Studio 2012 y versiones posteriores incluye LocalDB. Durante la instalación, el paquete NuGet de EntityFramework comprueba qué servidor de bases de datos está disponible. Después, el paquete NuGet actualizará el archivo de configuración estableciendo el servidor de base de datos predeterminado que Code First usa al crear una conexión por convención. Si SQL Express se está ejecutando, se usará. Si SQL Express no está disponible, LocalDB se registrará como predeterminado en su lugar. No se realizan cambios en el archivo de configuración si ya contiene una configuración para el generador de conexiones predeterminado.

Usar Code First con la conexión por convención y el nombre de base de datos especificado

Si no ha realizado ninguna otra configuración en la aplicación, llamar al constructor de cadena en DbContext con el nombre de la base de datos que desea usar hará que DbContext se ejecute en el modo Code First con una conexión de base de datos creada por convención con la base de datos de ese nombre. Por ejemplo:

public class BloggingContext : DbContext
{
    public BloggingContext()
        : base("BloggingDatabase")
    {
    }
}

En este ejemplo DbContext usa "BloggingDatabase" como nombre de la base de datos y crea una cadena de conexión para esta base de datos mediante SQL Express (instalado con Visual Studio 2010) o LocalDB (instalado con Visual Studio 2012). Si ambos están instalados, se usará SQL Express.

Uso de Code First con cadena de conexión en el archivo app.config/web.config

Puede elegir colocar una cadena de conexión en el archivo app.config o web.config. Por ejemplo:

<configuration>
  <connectionStrings>
    <add name="BloggingCompactDatabase"
         providerName="System.Data.SqlServerCe.4.0"
         connectionString="Data Source=Blogging.sdf"/>
  </connectionStrings>
</configuration>

Se trata de una manera sencilla de indicar a DbContext que use un servidor de base de datos distinto de SQL Express o LocalDB: el ejemplo anterior especifica una base de datos de SQL Server Compact Edition.

Si el nombre de la cadena de conexión coincide con el nombre del contexto (ya sea con o sin calificación de espacio de nombres), DbContext lo encontrará cuando se use el constructor sin parámetros. Si el nombre de la cadena de conexión es diferente del nombre del contexto, puede indicar a DbContext que use esta conexión en el modo Code First pasando el nombre de la cadena de conexión al constructor DbContext. Por ejemplo:

public class BloggingContext : DbContext
{
    public BloggingContext()
        : base("BloggingCompactDatabase")
    {
    }
}

Como alternativa, puede usar el formulario "name=<nombre de cadena de conexión>" para la cadena pasada al constructor DbContext. Por ejemplo:

public class BloggingContext : DbContext
{
    public BloggingContext()
        : base("name=BloggingCompactDatabase")
    {
    }
}

Este formulario hace explícito que espere que la cadena de conexión se encuentre en el archivo de configuración. Se producirá una excepción si no se encuentra una cadena de conexión con el nombre especificado.

Database/Model First con la cadena de conexión en el archivo de configuración app.config/web

Los modelos creados con el Diseñador de EF son diferentes de Code First en que el modelo ya existe y no se genera a partir del código cuando se ejecuta la aplicación. El modelo normalmente existe como un archivo EDMX en el proyecto.

El diseñador agregará una cadena de conexión de EF al archivo de configuración app.config o web.config. Esta cadena de conexión es especial en el hecho de que contiene información sobre cómo encontrar la información en su archivo EDMX. Por ejemplo:

<configuration>  
  <connectionStrings>  
    <add name="Northwind_Entities"  
         connectionString="metadata=res://*/Northwind.csdl|  
                                    res://*/Northwind.ssdl|  
                                    res://*/Northwind.msl;  
                           provider=System.Data.SqlClient;  
                           provider connection string=  
                               &quot;Data Source=.\sqlexpress;  
                                     Initial Catalog=Northwind;  
                                     Integrated Security=True;  
                                     MultipleActiveResultSets=True&quot;"  
         providerName="System.Data.EntityClient"/>  
  </connectionStrings>  
</configuration>

El Diseñador de EF también generará código que indica a DbContext que use esta conexión pasando el nombre de la cadena de conexión al constructor DbContext. Por ejemplo:

public class NorthwindContext : DbContext
{
    public NorthwindContext()
        : base("name=Northwind_Entities")
    {
    }
}

DbContext sabe cargar el modelo existente (en lugar de usar Code First para calcularlo a partir del código) porque la cadena de conexión es una cadena de conexión de EF que contiene detalles del modelo que se va a usar.

Otras opciones del constructor DbContext

La clase DbContext contiene otros constructores y patrones de uso que permiten algunos escenarios más avanzados. Algunas de estas son:

  • Puede usar la clase DbModelBuilder para compilar un modelo de Code First sin crear instancias de una instancia de DbContext. El resultado de esto es un objeto DbModel. A continuación, puede pasar este objeto DbModel a uno de los constructores DbContext cuando esté listo para crear la instancia de DbContext.
  • Puede pasar una cadena de conexión completa a DbContext en lugar de simplemente el nombre de la cadena de conexión o la base de datos. De forma predeterminada, esta cadena de conexión se usa con el proveedor System.Data.SqlClient; esto se puede cambiar estableciendo una implementación diferente de IConnectionFactory en context.Database.DefaultConnectionFactory.
  • Puede usar un objeto DbConnection existente pasándolo a un constructor DbContext. Si el objeto de conexión es una instancia de EntityConnection, el modelo especificado en la conexión se usará en lugar de calcular un modelo mediante Code First. Si el objeto es una instancia de algún otro tipo (por ejemplo, SqlConnection), el contexto lo usará para el modo Code First.
  • Puede pasar un ObjectContext existente a un constructor DbContext para crear un DbContext que ajuste el contexto existente. Esto se puede usar para las aplicaciones existentes que usan ObjectContext, pero que quieren aprovechar DbContext en algunas partes de la aplicación.