Instruções passo a passo: acessando um banco de dados SQL por meio de provedores de tipos e entidades (F#)

Artigo
06/10/2015

Esse guia passo a passo para o F# 3.0 mostra como acessar dados tipados para um banco de dados SQL baseado no Modelo de Dados de Entidade ADO.NET. Esse guia passo a passo mostra como configurar o provedor de tipos SqlEntityConnection do F# para uso com um banco de dados SQL, como criar consultas para dados, como chamar procedimentos armazenados no banco de dados, bem como usar alguns métodos e tipos do ADO.NET Entity Framework para atualizar o banco de dados.

Esse guia passo a passo ilustra as seguintes tarefas que você deve executar nesta ordem para que as instruções sejam bem-sucedidas:

Criar o banco de dados escolar.
Criar e configurar um projeto F#.
Configurar o provedor de tipos e conectar ao Modelo de Dados de Entidade.
Consultar o banco de dados.
Atualizando o banco de dados

Pré-requisitos

Você deve ter acesso a um servidor que esteja executando um SQL Server onde você possa criar um banco de dados para concluir estas etapas.

Criar o banco de dados escolar

Você pode criar o banco de dados escolar em qualquer servidor que esteja executando um SQL Server ao qual você tenha acesso administrativo ou pode usar LocalDB.

Para criar o banco de dados escolar

No Gerenciador de Servidores, abra o menu de atalho para o nó Conexões de Dados e escolha Adicionar Conexão.

A caixa de diálogo Adicionar Conexão será exibida.
Na caixa Nome do servidor, especifique o nome de uma instância do SQL Server a qual você tenha acesso administrativo ou especifique (localdb\v11.0) se você não tiver acesso a um servidor.

O SQL Server Express LocalDB oferece um servidor de banco de dados leve para desenvolvimento e teste em seu computador. Para obter mais informações sobre LocalDB, consulte Instruções passo a passo: criando um arquivo de banco de dados local no Visual Studio.

Um novo nó será criado no Gerenciador de Servidores sob Conexões de Dados.
Abra o menu de atalho para o novo nó de conexão e escolha Nova Consulta.
Abra Criando o banco de dados de exemplo escolar no site da Microsoft e copie e cole o script de banco de dados que cria o banco de dados do aluno na janela do editor.

Criar e configurar um projeto F#

Nesta etapa, você criará um projeto e o configurará para usar um provedor de tipos.

Para criar e configurar um projeto F#

Feche o projeto anterior, crie outro projeto e o chame SchoolEDM.
No Gerenciador de Soluções, abra o menu de atalho para Referências e escolha Adicionar Referência.
Escolha o nó Framework e, na lista Framework, escolha System.Data, System.Data.Entity e System.Data.Linq.
Escolha o nó Extensões, adicione uma referência ao assembly FSharp.Data.TypeProviders e escolha o botão OK para descartar a caixa de diálogo.
Adicione o código a seguir para definir um módulo interno e abrir namespaces apropriados. O provedor de tipos pode injetar tipos somente em um namespace particular ou interno.
```
module internal SchoolEDM

open System.Data.Linq
open System.Data.Entity
open Microsoft.FSharp.Data.TypeProviders
```
Para executar o código nesse guia passo a passo interativamente como um script em vez de um programa compilado, abra o menu de atalho para o nó do projeto, escolha Adicionar Novo Item, adicione um arquivo de script F# e adicione o código em cada etapa ao script. Para carregar as referências de assembly, adicione as linhas a seguir.
```
#r "System.Data.Entity.dll"
#r "FSharp.Data.TypeProviders.dll"
#r "System.Data.Linq.dll"
```
Realce cada bloco de código conforme o adiciona e escolha as teclas Alt + Enter para executá-lo em F# Interativo.

Configurar o provedor de tipos e conectar ao Modelo de Dados de Entidade

Nesta etapa, você configura um provedor de tipos com uma conexão de dados e obtém um contexto de dados que permite trabalhar com dados.

Para configurar o provedor de tipos e conectar ao Modelo de Dados de Entidade

Insira o código a seguir para configurar o provedor de tipos SqlEntityConnection que gera tipos do F# com base no Modelo de Dados de Entidade que você criou anteriormente. Em vez da cadeia de conexão completa do EDMX, use apenas a cadeia de conexão SQL.
```
type private EntityConnection = SqlEntityConnection<ConnectionString="Server=SERVER\InstanceName;Initial Catalog=School;Integrated Security=SSPI;MultipleActiveResultSets=true",
                                                    Pluralize = true>
 >
```
Esta ação configura um provedor de tipos com a conexão de banco de dados que você criou anteriormente. A propriedade MultipleActiveResultSets é necessária quando você usa o ADO.NET Entity Framework porque essa propriedade permite que vários comandos sejam executados de modo assíncrono no banco de dados em uma conexão, isso pode ocorrer frequentemente no código do ADO.NET Entity Framework. Para obter mais informações, consulte Multiple Active Result Sets (MARS).
Obtenha o contexto de dados que é um objeto com tabelas do banco de dados como propriedades e procedimentos armazenados e funções do banco de dados como métodos.
```
let context = EntityConnection.GetDataContext()
```

Consultando o banco de dados

Nesta etapa, você usará expressões de consulta F# para executar várias consultas no banco de dados.

Para consultar os dados

Insira o código a seguir para consultar os dados do modelo de dados de entidade. Observe o efeito de Pluralize = true que altera Course para Courses e Person para People na tabela de banco de dados.

query { for course in context.Courses do
        select course }
|> Seq.iter (fun course -> printfn "%s" course.Title)

query { for person in context.People do
        select person }
|> Seq.iter (fun person -> printfn "%s %s" person.FirstName person.LastName)

// Add a where clause to filter results.
query { for course in context.Courses do
        where (course.DepartmentID = 1)
        select course }
|> Seq.iter (fun course -> printfn "%s" course.Title)

// Join two tables.
query { for course in context.Courses do
        join dept in context.Departments on (course.DepartmentID = dept.DepartmentID)
        select (course, dept.Name) }
|> Seq.iter (fun (course, deptName) -> printfn "%s %s" course.Title deptName)

Atualizando o banco de dados

Para atualizar o banco de dados, use as classes e os métodos do Entity Framework. Você pode usar dois tipos de contexto de dados com o provedor de tipos SQLEntityConnection. Primeiro, ServiceTypes.SimpleDataContextTypes.EntityContainer é o contexto de dados simplificado que inclui somente as propriedades fornecidas que representam tabelas e colunas do banco de dados. Segundo, o contexto de dados completo é uma instância da classe ObjectContext do Entity Framework que contém o método AddObject para adicionar linhas ao banco de dados. O Entity Framework reconhece as tabelas e os relacionamentos entre elas, assim, ele impõe consistência ao banco de dados.

Para atualizar o banco de dados

Adicione o código a seguir ao seu programa. Neste exemplo, você adiciona dois objetos com um relacionamento entre eles e um instrutor e uma atribuição comercial. A tabela OfficeAssignments contém a coluna InstructorID que faz referência à coluna PersonID na tabela Person.

// The full data context
let fullContext = context.DataContext

// A helper function.
let nullable value = new System.Nullable<_>(value)

let addInstructor(lastName, firstName, hireDate, office) =
    let hireDate = DateTime.Parse(hireDate)
    let newPerson = new EntityConnection.ServiceTypes.Person(LastName = lastName,
                                                FirstName = firstName,
                                                HireDate = nullable hireDate)
    fullContext.AddObject("People", newPerson)
    let newOffice = new EntityConnection.ServiceTypes.OfficeAssignment(Location = office)
    fullContext.AddObject("OfficeAssignments", newOffice)
    fullContext.CommandTimeout <- nullable 1000
    fullContext.SaveChanges() |> printfn "Saved changes: %d object(s) modified."

addInstructor("Parker", "Darren", "1/1/1998", "41/3720")

Nada será alterado no banco de dados até que você chame SaveChanges.

Agora, restaure o banco de dados ao seu estado anterior ao excluir os objetos que você adicionou.

let deleteInstructor(lastName, firstName) =
        query {
            for person in context.People do
            where (person.FirstName = firstName &&
                    person.LastName = lastName)
            select person
        }
        |> Seq.iter (fun person->
            query {
                for officeAssignment in context.OfficeAssignments do
                where (officeAssignment.Person.PersonID = person.PersonID)
                select officeAssignment }
            |> Seq.iter (fun officeAssignment -> fullContext.DeleteObject(officeAssignment))

            fullContext.DeleteObject(person))

        // The call to SaveChanges should be outside of any iteration on the queries.
        fullContext.SaveChanges() |> printfn "Saved changed: %d object(s) modified."

deleteInstructor("Parker", "Darren")

Aviso

Ao usar uma expressão de consulta, lembre-se de que a consulta estará sujeita a avaliação lenta.Portanto, o banco de dados ainda estará aberto para leitura durante quaisquer avaliações encadeadas como nos blocos de expressão lambda após cada expressão de consulta.Qualquer operação de banco de dados que usar explícita ou implicitamente uma transação deverá ocorrer depois que as operações de leitura forem concluídas.

Próximas etapas

Explore outras opções de consulta ao examinar os operadores de consulta disponíveis em Expressões de consulta (F#) e também revise o ADO.NET Entity Framework para entender qual funcionalidade estará disponível para você ao usar este provedor de tipos.

Consulte também

Compartilhar via