Instruktaż: Dostęp do bazy danych SQL za pomocą typu dostawcy oraz podmioty (F#)

Artykuł
03/12/2013

W tym przewodniku dla F# 3.0 pokazano, w jaki sposób uzyskać dostęp do danych w bazie danych SQL opartej o ADO.NET Entity Data Model.W tym przewodniku pokazano, w jaki sposób skonfigurować dostawcę typu F# SqlEntityConnection do używania z bazą danych SQL, jak pisać zapytania o dane, jak wywoływać procedury przechowywane w bazie danych, oraz w jaki sposób używać niektórych typów i metod ADO.NET Entity Framework, aby zaktualizować bazę danych.

Następujące zadania pokazane w tym przewodniku muszą zostać wykonane w podanej kolejności, aby ukończenie przewodnika powiodło się:

Utwórz bazę danych o nazwie School .
Utwórz i skonfiguruj projekt F# .
Skonfiguruj dostawcę typu i połącz go z Entity Data Model .
Wykonywanie zapytania na bazie danych .
Aktualizowanie bazy danych

Wymagania wstępne

Musisz mieć dostęp do serwera, na którym działa program SQL Server, w którym można utworzyć bazę danych do wykonania poniższych kroków.

Utwórz bazę danych o nazwie School

Bazę danych School możesz utworzyć na dowolnym serwerze, na którym działa program SQL Server i do którego masz dostęp administracyjny lub użyj LocalDB.

Aby utworzyć bazę danych School

W Eksploratorze serwera, otwórz menu skrótów węzła Połączenia danych, a następnie wybierz polecenie Dodaj połączenie.

Pojawi się okno dialogowe Dodaj połączenie.
W polu Nazwa serwera, określ nazwę wystąpienia programu SQL Server, do którego masz dostęp administracyjny lub, jeśli nie masz dostępu do serwera, określ (localdb\v11.0).

SQL Server Express LocalDB dostarcza lekki serwer bazy danych do rozwoju i testowania na twoim komputerze.Aby uzyskać więcej informacji o LocalDB, zobacz Wskazówki: tworzenie bazy danych LocalDB.

Nowy węzeł zostanie utworzony w Eksploratorze serwera pod Połączenia danych.
Otwórz menu skrótów nowego węzła połączenia, a następnie wybierz Nowe zapytanie.
Otwórz Tworzenie przykładowej bazy danych School w witrynie sieci Web firmy Microsoft, a następnie skopiuj i wklej do okna edytora skrypt, który tworzy bazę danych o nazwie Student.

Następne kroki w tym przewodniku są oparte na następującym samouczku: ADO.NET Entity Data Model Quickstart.

Utwórz i skonfiguruj projekt F#

W tym kroku, utworzysz projekt i skonfigurujesz go do używania dostawcy typu.

Aby utworzyć i skonfigurować projekt F#

Zamknij wszystkie poprzednie projekty i utwórz nowy projekt o nazwie SchoolEDM.
W oknie Eksploratora rozwiązań otwórz menu skrótów Odwołania, a następnie wybierz polecenie Dodaj odwołanie.
Wybierz węzeł Platforma, a następnie, na liście Platforma, wybierz System.Data, System.Data.Entity i System.Data.Linq.
Wybierz węzeł Rozszerzenia, dodaj odwołanie do zestawu FSharp.Data.TypeProviders, a następnie kliknij przycisk Ok, aby zamknąć okno dialogowe.
Dodaj następujący kod, aby zdefiniować wewnętrzny moduł i otworzyć odpowiednie przestrzenie nazw.Dostawca typu może wstrzyknąć typy tylko do prywatnej lub wewnętrznej przestrzeni nazw.
```
module internal SchoolEDM

open System.Data.Linq
open System.Data.Entity
open Microsoft.FSharp.Data.TypeProviders
```
Aby uruchomić kod z tego przewodnika interakcyjnie, jako skrypt, zamiast jako skompilowany program, otwórz menu skrótów węzła projektu, wybierz polecenie Dodaj nowy element, dodaj plik skryptu F#, a następnie dodawaj kod skryptu w każdym kroku przewodnika.Aby załadować odwołania zestawu, dodaj następujące wiersze kodu.
```
#r "System.Data.Entity.dll"
#r "FSharp.Data.TypeProviders.dll"
#r "System.Data.Linq.dll"
```
Zaznacz każdy blok kodu, który dodajesz i użyj klawiszy Alt+Enter, aby uruchomić go w F# interakcyjnie.

Skonfiguruj dostawcę typu i połącz go z Entity Data Model

W tym kroku, skonfigurujesz dostawcę typu z połączeniem danych, aby uzyskać kontekst danych, który umożliwi pracę z danymi.

Aby skonfiguruj dostawcę typu i połączyć go z Entity Data Model

Wprowadź następujący kod, aby skonfigurować dostawcę typ SqlEntityConnection, który wygeneruje typy F# w oparciu o Entity Data Model, który został utworzony wcześniej.Zamiast pełnych parametrów połączenia EDMX, użyj jedynie parametrów połączenia SQL.
```
type private EntityConnection = SqlEntityConnection<ConnectionString="Server=SERVER\InstanceName;Initial Catalog=School;Integrated Security=SSPI;MultipleActiveResultSets=true",
                                                    Pluralize = true>
 >
```
Ta akcja ustawia dostawcę typu z połączeniem do bazy danych, które zostało utworzone wcześniej.Właściwość MultipleActiveResultSets jest wymagana, gdy używasz ADO.NET Entity Framework, ponieważ właściwość ta umożliwia asynchroniczne wykonanie wielu poleceń na bazie danych w ramach jednego połączenia, co może często występować w kodzie ADO.NET Entity Framework.Aby uzyskać więcej informacji, zobacz Obsługa wielu aktywnych zestawów wyników (MARS).
Pobierz kontekst danych, który jest obiektem zawierającym tabele bazy danych jako właściwości oraz procedury i funkcje przechowywane w bazie danych jako metody.
```
let context = EntityConnection.GetDataContext()
```

Wykonywanie zapytania na bazie danych

W tym kroku, użyjesz wyrażenia zapytania F#, aby wykonać różne zapytania do bazy danych.

Aby utworzyć zapytanie do danych

Wprowadź następujący kod, aby utworzyć zapytanie o dane do Entity Data Model.Zauważ efekt działania ustawienia Pluralize = true, który zmienia nazwy tabel bazy danych z Course na Courses i z Person na 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)

Aktualizowanie bazy danych

Aby zaktualizować bazę danych, użyj klas i metod Entity Framework.Możesz użyć dwóch typów kontekstu danych z dostawcą typu SQLEntityConnection.Pierwszy, ServiceTypes.SimpleDataContextTypes.EntityContainer, jest uproszczonym kontekstem danych, który zawiera tylko dostarczone właściwości, które reprezentują tabele i kolumny bazy danych.Drugi, pełny kontekst danych, jest wystąpieniem klasy Entity Framework ObjectContext, która zawiera metodę AddObject do dodawania wierszy do bazy danych.Entity Framework rozpoznaje tabele i relacje między nimi, a więc wymusza spójność bazy danych.

Aby zaktualizować bazę danych

Dodaj poniższy kod do programu.W tym przykładzie, dodasz dwa obiekty powiązane relacją, a następnie dodasz instruktora oraz przypisane biuro.Tabela OfficeAssignments zawiera kolumnę InstructorID, która odwołuje się do kolumny PersonID w tabeli 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")

Nic nie zostanie zmienione w bazie danych, dopóki nie zostanie wywołana metoda SaveChanges.

Teraz przywróć bazę danych do wcześniejszego stanu, usuwając obiekty, które zostały dodane.

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

Przestroga
Gdy używasz wyrażeń zapytania, musisz pamiętać, że zapytanie jest obliczane leniwie.Z tego powodu, baza danych jest nadal otwarta do odczytu podczas dowolnych obliczeń łańcuchowych, takich jak bloki wyrażenia lambda po każdym wyrażeniu zapytania.Dowolna operacja na bazie danych, która jawnie lub niejawnie używa transakcji, musi nastąpić po zakończeniu operacji odczytu.

Następne kroki

Odkryj inne opcje zapytań, przeglądając operatory zapytania dostępne w Wyrażenia w kwerendzie (F#), a także przejrzyj ADO.NET Entity Framework, aby zrozumieć, jakie funkcje są dostępne podczas korzystania z tego dostawcy typu.

Zobacz też

Udostępnij za pośrednictwem