Tutorial: Obtener acceso a una base de datos SQL mediante proveedores de tipo y entidades (F#)

Artículo
02/19/2013

Este tutorial sobre F# 3.0 muestra cómo obtener acceso a los datos escritos para una base de datos SQL basándose en el ADO.NET Entity Data Model.En este tutorial se muestra cómo configurar el proveedor de tipos de F# SqlEntityConnection con una base de datos SQL, cómo escribir consultas en los datos, cómo llamar a procedimientos almacenados en la base de datos y cómo utilizar algunos de los tipos y métodos de ADO.NET Entity Framework para actualizar la base de datos.

Este tutorial muestra las siguientes tareas, que se deben realizar en el orden presentado a continuación para finalizarlo con éxito:

Cómo crear la base de datos School .
Cómo crear y configurar un proyecto F# .
Cómo Configurar el proveedor de tipos y conectarse al Entity Data Model .
Cómo consultar la base de datos .
Cómo actualizar la base de datos

Requisitos previos

Se debe tener acceso a un servidor que esté ejecutando SQL Server donde se pueda crear una base de datos para completar estos pasos.

Cómo crear la base de datos School

Se puede crear la base de datos School en cualquier servidor que ejecute SQL Server al que tenga acceso administrativo o se puede utilizar LocalDB.

Para crear la base de datos School.

Abra en el Explorador de servidores el acceso directo para el nodo Conexiones de datos y elija Agregar conexión.

Aparecerá el cuadro de diálogo Agregar conexión.
Especifique en el cuadro Nombre del servidor el nombre de una instancia de SQL Server a la que tenga acceso administrativo, o especifíque (localdb\v11.0) si no tiene acceso a un servidor.

SQL Server Express LocalDB proporciona un servidor de bases de datos ligero para el desarrollo y las pruebas en el equipo.Para obtener más información acerca de LocalDB, consulte Tutorial: Crear una base de datos LocalDB.

Se crea un nuevo nodo en el Explorador de servidores bajo Conexiones de datos.
Abra el acceso directo para el nuevo nodo de conexión y, a continuación, elija Nueva consulta.
Abra Crear la base de datos de ejemplo School en el sitio Web de Microsoft y luego copie y pegue el script de base de datos que crea la base de datos Student en la ventana del editor.

Los siguientes pasos de este tutorial se basan en el tutorial: ADO.NET Entity Data Model Quickstart.

Cómo crear y configurar un proyecto F#

En este paso, se crea un proyecto y se configura para usar un proveedor de tipos.

Para crear y configurar un proyecto F#

Cierre el proyecto anterior, cree otro proyecto, y denomínelo SchoolEDM.
En el Explorador de soluciones, haga clic en el acceso directo Referencias y, a continuación, elija Agregar referencia.
Elija el nodo Framework y, a continuación, en la lista Framework elija System.Data, System.Data.Entity, y System.Data.Linq.
Elija el nodo Extensiones, agregue una referencia al ensamblado FSharp.Data.TypeProviders y haga clic en el botón ACEPTAR para descartar el cuadro de diálogo.
Agregue el código siguiente para definir un módulo interno y abrir los espacios de nombres adecuados.El proveedor de tipos puede insertar tipos sólo en un espacio de nombres privado o interno.
```
module internal SchoolEDM

open System.Data.Linq
open System.Data.Entity
open Microsoft.FSharp.Data.TypeProviders
```
Para ejecutar el código de este tutorial interactivamente como un script en lugar de como un programa compilado, abra el acceso directo para el nodo del proyecto, elija Agregar nuevo elemento, agregue un archivo de script de F# y agregue el código en cada paso al script.Para cargar las referencias de ensamblado, agregue las líneas siguientes.
```
#r "System.Data.Entity.dll"
#r "FSharp.Data.TypeProviders.dll"
#r "System.Data.Linq.dll"
```
Resalte cada bloque de código al agregarlo y presione las teclas ALT + ENTRAR para ejecutarlo en modo F# interactivo.

Cómo Configurar el proveedor de tipos y conectarse al Entity Data Model

En este paso, se configura un proveedor de tipos con una conexión de datos y se obtiene un contexto de datos que permite trabajar con dichos datos.

Para configurar el proveedor de tipos y conectarse al Entity Data Model

Escriba el código siguiente para configurar el proveedor de tipos SqlEntityConnection que genera los tipos de F# basados en el Entity Data Model creado previamente.En lugar de la cadena de conexión completa EDMX, utilice sólo la cadena de conexión SQL.
```
type private EntityConnection = SqlEntityConnection<ConnectionString="Server=SERVER\InstanceName;Initial Catalog=School;Integrated Security=SSPI;MultipleActiveResultSets=true",
                                                    Pluralize = true>
 >
```
Esta acción configura un proveedor de tipos con la conexión a bases de datos que se ha creado anteriormente.La propiedad MultipleActiveResultSets es necesaria cuando se utiliza ADO.NET Entity Framework porque permite que varios comandos se ejecuten de forma asíncrona en la base de datos en una conexión, que puede producirse con frecuencia en el código de ADO.NET Entity Framework.Para obtener más información, vea Conjuntos de resultados activos múltiples (MARS).
Obtenga el contexto de datos, que es un objeto que contiene las tablas de base de datos como propiedades y procedimientos almacenados y funciones de base de datos como métodos.
```
let context = EntityConnection.GetDataContext()
```

Cómo consultar la base de datos

En este paso, se utilizan las expresiones de consulta de F# para ejecutar varias consultas en la base de datos.

Para consultar los datos

Escriba el código siguiente para consultar los datos del modelo de datos de entidades.Observe el efecto de Pluralize = true, que cambia Course a Courses y Person a People en la tabla de la base de datos.

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)

Cómo actualizar la base de datos

Para actualizar la base de datos, se usan las clases y métodos de Entity Framework.Se pueden utilizar dos tipos de contexto de datos con el proveedor de tipos SQLEntityConnection.En primer lugar, ServiceTypes.SimpleDataContextTypes.EntityContainer es el contexto de datos simplificado, que incluye solamente las propiedades proporcionadas que representan tablas y columnas de bases de datos.En segundo lugar, el contexto de datos completo es una instancia de la clase ObjectContextde Entity Framework, que contiene el método AddObject para agregar filas a la base de datos.Entity Framework reconoce las tablas y las relaciones entre ellas, por lo que refuerza la consistencia de la base de datos.

Para actualizar la base de datos

Agregue el código siguiente al programa:En este ejemplo, se agregan dos objetos con una relación entre ellos y se agrega un instructor y una asignación de oficina.La tabla OfficeAssignments contiene la columna InstructorID, que hace referencia a la columna PersonID en la tabla 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")

No se cambia nada en la base de datos hasta que se llame a SaveChanges.

Ahora restaure la base de datos a su estado anterior eliminando los objetos que agregó.

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

Precaución
Cuando se usa una expresión de consulta, debe recordar que la consulta está sujeta a evaluación perezosa.Por tanto, la base de datos sigue abierta para lectura durante cualquier evaluación encadenada, por ejemplo en los bloques de la expresión lambda después de cada expresión de consulta.Cualquier operación de base de datos que utilice implícita o explícitamente una transacción debe aparecer después de que las operaciones de lectura se hayan completado.

Cuando se usa una expresión de consulta, debe recordar que la consulta está sujeta a evaluación perezosa.Por tanto, la base de datos sigue abierta para lectura durante cualquier evaluación encadenada, por ejemplo en los bloques de la expresión lambda después de cada expresión de consulta.Cualquier operación de base de datos que utilice implícita o explícitamente una transacción debe aparecer después de que las operaciones de lectura se hayan completado.

Pasos siguientes

Explore otras opciones de consulta revisando los operadores de consulta disponibles en Expresiones de consulta (F#), y también revise ADO.NET Entity Framework para entender qué funcionalidad está disponible para que se pueda utilizar este proveedor de tipos.

Vea también