Procédure pas à pas : accès à une base de données SQL à l'aide des fournisseurs de type et des entités (F#)

Article
06/10/2015

Cette procédure pas à pas pour F# 3.0 indique comment accéder à des données typées pour une base de données SQL sur ADO.NET Entity Data Model. Cette procédure pas à pas indique comment installer le fournisseur de type F# SqlEntityConnection à utiliser avec une base de données SQL, comment écrire des requêtes sur les données, comment appeler des procédures stockées sur la base de données, et comment utiliser certains types et méthodes ADO.NET Entity Framework pour mettre à jour la base de données.

Les tâches suivantes, décrites dans cette procédure pas à pas, doivent être exécutées dans cet ordre pour la réussite de cette dernière :

Créez la base de données School.
Créez et configurez un projet F#.
Configurez le fournisseur de type, puis connectez-vous à l'Entity Data Model.
Interrogez la base de données.
Mise à jour de la base de données

Composants requis

Vous devez avoir accès à un serveur qui exécute SQL Server sur lequel vous pouvez créer une base de données pour effectuer ces étapes.

Créer la base de données School

Vous pouvez créer la base de données School sur un serveur qui exécute SQL Server et auquel vous avez un accès administratif, ou vous pouvez utiliser LocalDB.

Pour créer la base de données School

Dans l'Explorateur de serveurs, ouvrez le menu contextuel du nœud Connexions de données, puis choisissez Ajouter une connexion.

La boîte de dialogue Ajouter une connexion s'affiche.
Dans la zone Nom du serveur, spécifiez le nom d'une instance de SQL Server à laquelle vous avez un accès administratif, ou spécifiez (localdb \ v11.0) si vous n'avez pas accès à un serveur.

SQL Server Express LocalDB fournit un serveur de base de données léger pour le développement et les tests sur votre ordinateur. Pour plus d’informations sur les LocalDB, consultez Procédure pas à pas : création d'un fichier de base de données local dans Visual Studio.

Un nœud est créé dans l'Explorateur de serveurs sous Connexions de données.
Ouvrez le menu contextuel pour le nouveau nœud de connexion, puis choisissez Nouvelle requête.
Ouvrez Création de l'exemple de base de données School sur le site Microsoft, puis copiez et collez le script de base de données qui crée la base de données Student dans la fenêtre de l'éditeur.

Créer et configurer un projet F#

Dans cette étape, vous créez un projet et le configurez pour utiliser un fournisseur de type.

Pour créer et configurer un projet F#

Fermez le projet précédent, créez un autre projet, et nommez-le SchoolEDM.
Dans l'Explorateur de solutions, ouvrez le menu contextuel Références, puis choisissez Ajouter une référence.
Choisissez le nœud framework, puis, dans la liste Framework, choisissez System.Data, System.Data.Entity, et System.Data.Linq.
Choisissez le nœud Extensions, ajoutez une référence à l'assembly FSharp.Data.TypeProviders, puis choisissez le bouton OK pour faire disparaître la boîte de dialogue.
Ajoutez le code suivant pour définir un module interne et ouvrir les espaces de noms appropriés. Le fournisseur de type peut injecter des types uniquement dans un espace de noms privé ou interne.
```
module internal SchoolEDM

open System.Data.Linq
open System.Data.Entity
open Microsoft.FSharp.Data.TypeProviders
```
Pour exécuter le code dans cette procédure pas à pas en mode interactif en tant que script et non comme programme compilé, ouvrez le menu contextuel du nœud de projet, choisissez Ajouter un nouvel élément, ajoutez un fichier de script F#, puis ajoutez le code dans chaque étape du script. Pour charger les références d'assembly, ajoutez les lignes suivantes.
```
#r "System.Data.Entity.dll"
#r "FSharp.Data.TypeProviders.dll"
#r "System.Data.Linq.dll"
```
Mettez en surbrillance chaque bloc de code au fur et à mesure que vous l'ajoutez, puis appuyez sur Alt+Entrée pour l'exécuter dans F# Interactive.

Configurer le fournisseur de type et se connecter à l'Entity Data Model

Dans cette étape, vous configurez un fournisseur de type avec une connexion de données et obtenez un contexte de données qui vous permet d'utiliser des données.

Pour configurer le fournisseur de type et se connecter à l'Entity Data Model

Entrez le code suivant pour configurer le fournisseur de type SqlEntityConnection qui génère des types F# basés sur l'Entity Data Model que vous avez créés précédemment. Au lieu de la chaîne de connexion complète EDMX, utilisez uniquement la chaîne de connexion SQL.
```
type private EntityConnection = SqlEntityConnection<ConnectionString="Server=SERVER\InstanceName;Initial Catalog=School;Integrated Security=SSPI;MultipleActiveResultSets=true",
                                                    Pluralize = true>
 >
```
Cette action configure un fournisseur de type avec la connexion de base de données que vous avez créée précédemment. La propriété MultipleActiveResultSets est nécessaire lorsque vous utilisez ADO.NET Entity Framework, car cette propriété permet à plusieurs commandes de s'exécuter de façon asynchrone sur la base de données dans une connexion, ce qui peut se produire fréquemment dans le code ADO.NET Entity Framework. Pour plus d'informations, consultez Utilisation de MARS (Multiple Active Result Sets).
Obtenez le contexte de données, qui est un objet qui contient les tables de base de données en tant que propriétés et les procédures et fonctions stockées de base de données en tant que méthodes.
```
let context = EntityConnection.GetDataContext()
```

Interroger la base de données

Dans cette étape, vous utilisez des expressions de requête F# pour exécuter diverses requêtes sur la base de données.

Pour interroger les données

Entrez le code suivant pour interroger les données de l'Entity Data Model. Notez l'effet de Pluralize = true, qui modifie la table de base de données Course par Courses et Person par People.

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)

Mise à jour de la base de données

Pour mettre à jour la base de données, vous utilisez les classes et les méthodes Entity Framework. Vous pouvez utiliser deux types de contexte de données avec le fournisseur de type SQLEntityConnection. En premier lieu, ServiceTypes.SimpleDataContextTypes.EntityContainer est le contexte de données simplifié, qui inclut uniquement les propriétés fournies qui représentent des tables et des colonnes de base de données. Ensuite, le contexte de données complet est une instance de la classe Entity Framework ObjectContext, qui contient la méthode AddObject pour ajouter des lignes à la base de données. L'Entity Framework reconnaît des tables et des relations entre elles, ce qui garantit la cohérence de base de données.

Pour mettre à jour la base de données

Ajoutez le code suivant à votre programme. Dans cet exemple, vous ajoutez deux objets ayant une relation entre eux, et vous ajoutez un formateur et une attribution de lieu de travail. Le tableau OfficeAssignments contient la colonne InstructorID, qui référence la colonne PersonID dans le tableau 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")

Rien n'est modifié dans la base de données jusqu'à ce que vous appeliez SaveChanges.

À présent, restaurez la base de données afin qu'elle retrouve son précédent état en supprimant les objets que vous avez ajoutés.

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")

Avertissement

Lorsque vous utilisez une expression de requête, gardez en mémoire que la requête est sujette à l'évaluation tardive.Par conséquent, la base de données est encore ouverte pour lecture pendant les évaluations chaînées, comme dans les blocs d'expression lambda après chaque expression de requête.Toute opération de base de données qui utilise explicitement ou implicitement une transaction doit se produire après que les opérations de lecture soient terminées.

Étapes suivantes

Découvrez d'autres options de requête en examinant les opérateurs de requête disponibles dans Expressions de requête (F#), et examinez également ADO.NET Entity Framework pour savoir quelle fonctionnalité est disponible lorsque vous utilisez ce fournisseur de type.

Voir aussi

Partager via