Passo a passo: Acessando um banco de dados SQL por meio de provedores de tipo e entidades (F#)

Artigo
02/25/2013

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 tipo SqlEntityConnection do F# para uso com um banco de dados SQL, como escrever consultas nos dados, como chamar procedimentos armazenados no banco de dados, bem como usar um pouco dos 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 o guia cumprido sua função:

Criar o banco de dados da Escola .
Criar e configurar um projeto F# .
Configurar o provedor de tipo, e conectar-se ao Modelo de Dados de Entidade .
Consultando o banco de dados .
Atualizando o banco de dados

Pré-requisitos

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

Criar o banco de dados da Escola

Você pode criar o banco de dados da Escola em qualquer servidor que esteja executando o SQL Server para o qual você tenha acesso administrativo, ou você pode usar LocalDB.

Para criar o banco de dados da Escola

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

Aparecerá a caixa de diálogo Add Connection.
Na caixa Nome do servidor, especifique o nome de uma instância do SQL Server que você tenha acesso administrativo, ou especifique (localdb\v11.0) se você não tiver acesso a um servidor.

O SQL Server Express LocalDB fornece um servidor de banco de dados leve para desenvolvimento e os testes no seu computador.Para obter mais informações sobre LocalDB, veja Instruções passo a passo: criando um banco de dados LocalDB.

Um novo nó é criado no Gerenciador de Servidores em baixo de Conexões de Dados.
Abra o menu de atalho para o novo nó de conexão, e então clique em Nova Consulta.
Abra Criando o Banco de Dados de Exemplo de Escola no site da Microsoft, e então copie e cole o script do banco de dados que cria o banco de dados do aluno na janela do editor.

As próximas etapas nesse guia são baseadas neste tutorial: ADO.NET Entity Data Model Quickstart.

Criar e configurar um projeto F#

Nesta etapa, você cria um projeto e o configura para usar um provedor de tipo.

Para criar e configurar um projeto F#

Feche o projeto anterior, crie outro projeto, e nomei-o SchoolEDM.
No Gerenciador de Soluções, abra o menu de atalho para Referências, e então clique em Adicionar Referência.
Escolha o nó Estrutura e, em seguida, na lista estrutura, clique em System.Data, System.Data.Entity, e System.Data.Linq.
Escolha o nó Extensões, adicione uma referência ao assembly FSharp.Data.TypeProviders, e então clique no botão OK para descartar a caixa de diálogo.
Adicione o seguinte código para definir um módulo interno e abrir namespaces apropriados.O provedor de tipo pode inserir tipos somente em um namespace privado 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 interativamente como um script em vez de como um programa compilado, abra o menu de atalho para o nó do projeto, clique em Adicionar Novo Item, adicione um arquivo de script F# em seguida, adicione o código em cada etapa para o script.Para carregar as referências de assembly, adicione as seguintes linhas.
```
#r "System.Data.Entity.dll"
#r "FSharp.Data.TypeProviders.dll"
#r "System.Data.Linq.dll"
```
Destaque cada bloco de código a medida que você os adiciona, e pressione as teclas ALT + ENTER para executá-lo em F# Interativo.

Configurar o provedor de tipo, e conectar-se ao Modelo de Dados de Entidade

Nesta etapa, você configura um provedor de tipo com uma conexão de dados e recebe um contexto de dados que permite que você trabalhe com dados.

Para Configurar o provedor de tipo, e conectar-se ao Modelo de Dados de Entidade

Insira o código a seguir para configurar o provedor de tipo 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 tipo 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 múltiplos comandos sejam executados de modo assíncrono no banco de dados em uma conexão, o que pode ocorrer freqüentemente 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 que contém as tabelas do banco de dados como propriedades e procedimentos armazenados do banco de dados e funções como métodos.
```
let context = EntityConnection.GetDataContext()
```

Consultando o banco de dados

Nesta etapa, você usa expressões de consulta do 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, o que altera o Curso da tabela de banco de dados para Cursos (Course para Courses) e Pessoa para Pessoas (Person para Pessoas).

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, você usa as classes e métodos do Entity Framework.Você pode usar dois tipos de contexto de dados com o provedor de tipo SQLEntityConnection.Primeiro, ServiceTypes.SimpleDataContextTypes.EntityContainer é o contexto de dados simplificado, o que inclui somente as propriedades fornecidas que representam as colunas e tabelas do banco de dados.Segundo, o contexto completo de dados é uma instância da classe ObjectContextdo entity framework, que contém o método AddObject para adicionar linhas ao banco de dados.O Entity Framework reconhece as tabelas e a relação entre elas, assim ele impõe a consistência do banco de dados.

Para atualizar o banco de dados

Adicione o seguinte código ao seu programa.Neste exemplo, você adiciona dois objetos com uma relação entre eles, e você adiciona um instrutor e uma atribuição de escritório.A tabela OfficeAssignments contém a coluna InstructorID, que faz referência a 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 para o seu estado anterior excluindo 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")

Cuidado
Quando você usa uma expressão de consulta, você deve se lembrar que a consulta é sujeita a avaliação lenta.Portanto, o banco de dados ainda está aberto para leitura em qualquer avaliação encadeada, 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 deve ocorrer depois que as operações de leitura terminarem.

Quando você usa uma expressão de consulta, você deve se lembrar que a consulta é sujeita a avaliação lenta.Portanto, o banco de dados ainda está aberto para leitura em qualquer avaliação encadeada, 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 deve ocorrer depois que as operações de leitura terminarem.

Próximas etapas

Explore outras opções de consulta examinando os operadores de consulta disponíveis em Expressões de consulta (F#), e também revise o ADO.NET Entity Framework para entender que funcionalidade está disponível para você quando você usar esse provedor de tipo.

Consulte também

Partilhar via