Um dos novos recursos disponíveis no Entity Framework 6 é a possibilidade de criar novas instâncias de contexto utilizando uma instância de DbConnection ativa. Operações que mesclam comandos em ADO.Net e com o Entity Framework podem fazer uso deste recurso.

No Entity Framework 6, a classe DbContext ganhou novas assinaturas para seus construtores, permitindo o uso de uma instância ativa de DbConnection para criação de um novo contexto. Para ver todos os construtores disponíveis na classe DbContext acesse este link: http://msdn.microsoft.com/en-us/library/system.data.entity.dbcontext(v=vs.103).aspx

Para essa demonstração utilizaremos o seguinte construtor:

public DbContext (
     DbConnection existingConnection,
     bool contextOwnsConnection
)

Esse construtor exige a passagem de dois parâmetros, sendo eles: existingConnection, instância ativa de um DbConnection que será utilizado para todas operações realizadas pelo DbContext; e contextOwnsConnection, booleano que indica se o DbConnection passado por parâmetro pode ser destruído quando a instância do DbContext for destruída ou se sua instância deve ser mantida ativa após a destruição da instância de DbContext.

A documentação oficial deste construtor pode ser acessada por este link: http://msdn.microsoft.com/en-us/library/gg696604(v=vs.103).aspx

Exemplo

Para demonstrar o uso de instâncias ativas de DbConnections na construção de novas instâncias de DbContexts, utilizaremos uma entidade com uma estrutura bastante simples, como pode ser visto abaixo.

O código necessário para criação dessa estrutura esta disponível a seguir:

     public class CustomInfo {
        public int Id { get ; set ; }
        public Guid GlobalId { get ; set ; }
        public string Content { get ; set ; }
    }

O contexto do Entity Framework a ser utilizado deverá expor em seu construtor recursos que permitam a passagem da instância ativa de um DbConnection. O exemplo abaixo demonstra exatamente isso. Note que um dos construtores do contexto expõe um DbConnection e um booleano como parâmetros, assim como discutido anteriormente. Vale ressaltar também que só passar os parâmetros não é suficiente, também é preciso encaminhar os valores destes parâmetros para a classe base. 

public class DataContext : DbContext {
    public DbSet<CustomInfo> CustomInfo { get; set; }
    public DataContext(string connectionString)
        : base(connectionString) {
        InitializeContext();
    }
    public DataContext()
        : base("Key name on App.Config/Web.Config") {
        InitializeContext();
    }
    public DataContext(DbConnection connection, bool contextOwnsConnection)
        : base(connection, contextOwnsConnection) {
        InitializeContext();
    }
    private void InitializeContext() {
        Database.SetInitializer<DataContext>(null);
    }
    protected override void OnModelCreating(DbModelBuilder modelBuilder) {
        modelBuilder.Entity<CustomInfo>().ToTable("CustomInfo");
        base.OnModelCreating(modelBuilder);
    }
}

Na estrutura deste contexto podemos notar a existência de três construtores distintos, onde um destes construtores é próprio para a demonstração de uso de um DbConnection ativo para execução de comandos com um DbContext do Entity Framework.

Abaixo temos o exemplo de uso de um DbContext com um DbConnection ativo. Note que estamos criando o DbConnection dentro de um bloco USING e passando o valor FALSE para o parâmetro "contextOwnsConnection", indicando que o DbContext não ficará responsável pela destruição da instância de DbConnection.

string connectionString = "Your connection string...";
const string ICOMMAND = "INSERT INTO CustomInfo (GlobalId, Content) VALUES (@GlobalId, @Content)";
var info = new CustomInfo();
info.GlobalId = Guid.NewGuid();
info.Content = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
using (DbConnection conn = new SqlConnection(connectionString)) {
    var sqlCommand = conn.CreateCommand();
    sqlCommand.CommandText = ICOMMAND;
    sqlCommand.CommandType = CommandType.Text;
    sqlCommand.Parameters.Add(new SqlParameter("GlobalId", info.GlobalId));
    sqlCommand.Parameters.Add(new SqlParameter("Content", info.Content));
    conn.Open();
    sqlCommand.ExecuteNonQuery();
    using (var context = new DataContext(conn, true)) {
        var query = from c in context.CustomInfo
                    where c.GlobalId == info.GlobalId
                    select c;
        foreach (var resultItemQuery in query) {
            Console.WriteLine(resultItemQuery.Content);
        }
    }
    conn.Close();
}

Espero que esse conteúdo seja útil.

Por

MSc. Fernando Henrique Inocêncio Borba Ferreira

Microsoft Most Valuable Professional – Visual C#

Referências:

http://msdn.microsoft.com/en-us/library/gg696604(v=vs.103).aspx

http://msdn.microsoft.com/en-us/library/system.data.entity.dbcontext.dbcontext(v=vs.103).aspx

http://blogs.msdn.com/b/adonet/archive/2013/08/21/ef6-release-candidate-available.aspx