El modelo de objetos de LINQ to SQL
En LINQ to SQL, el modelo de datos de una base de datos relacional se asigna a un modelo de objetos expresado en el lenguaje de programación del programador. Así, las operaciones con los datos se realizan según el modelo de objetos.
En este escenario, no ejecuta comandos de base de datos (como INSERT) en la base de datos. En su lugar, cambia los valores y ejecuta los métodos de su modelo de objetos. Si desea consultar la base de datos o enviar cambios, LINQ to SQL convierte sus solicitudes en los comandos SQL correctos y los envía a la base de datos.
En la tabla siguiente se resumen los elementos más fundamentales del modelo de objetos de LINQ to SQL y su relación con los elementos del modelo de datos relacionales:
| Modelo de objetos LINQ to SQL | Modelo de datos relacionales |
|---|---|
| Clase de entidad | Tabla |
| Miembro de clase | Columna |
| Asociación | Relación de clave externa |
| Método | Procedimiento almacenado o función |
Nota:
En las líneas siguientes se asume que tiene conocimientos básicos del modelo de datos relacionales y sus reglas.
Tablas de base de datos y clases de entidad en LINQ to SQL
En LINQ to SQL, una tabla de base de datos se representa mediante una clase de entidad. Una clase de entidad es como cualquier otra clase que se pueda crear, con la salvedad de que se anota utilizando información especial que asocia la clase a una tabla de base de datos. Para realizar esta anotación, se agrega un atributo personalizado (TableAttribute) a la declaración de clase, como en el ejemplo siguiente:
Ejemplo
[Table(Name = "Customers")]
public class Customerzz
{
public string CustomerID;
// ...
public string City;
}
<Table(Name:="Customers")> _
Public Class Customer
Public CustomerID As String
' ...
Public City As String
End Class
Solo las instancias de clases declaradas como tablas (es decir, clases de entidad) pueden guardarse en la base de datos.
Para más información, consulte la sección relativa a TableAttribute de Asignación basada en atributos.
Miembros de clase y columnas de base de datos en LINQ to SQL
Además de asociar clases a tablas, se designan campos o propiedades para representar columnas de base de datos. Para este propósito, LINQ to SQL define el atributo ColumnAttribute, como en el ejemplo siguiente:
Ejemplo
[Table(Name = "Customers")]
public class Customer
{
[Column(IsPrimaryKey = true)]
public string CustomerID;
[Column]
public string City;
}
<Table(Name:="Customers")> _
Public Class Customer
<Column(IsPrimaryKey:=True)> _
Public CustomerID As String
<Column()> _
Public City As String
End Class
Solo los campos y las propiedades que estén asignados a columnas se conservan en la base de datos o se recuperan de ella. Si no se han declarado como columnas, se consideran partes transitorias de la lógica de aplicación.
El atributo ColumnAttribute tiene varias propiedades que se pueden utilizar para personalizar los miembros que representan columnas (por ejemplo, para designar un miembro como representativo de una columna de clave principal). Para más información, consulte la sección relativa ColumnAttribute de Asignación basada en atributos.
Asociaciones y relaciones de clave externa de base de datos en LINQ to SQL
En LINQ to SQL, las asociaciones de base de datos (como las relaciones de clave externa y clave principal) se representan aplicando el atributo AssociationAttribute. En el segmento de código siguiente, la clase Order contiene una propiedad Customer que tiene un atributo AssociationAttribute. Esta propiedad y su atributo proporcionan a la clase Order una relación con la clase Customer.
En el ejemplo de código siguiente se muestra la propiedad Customer de la clase Order.
Ejemplo
[Association(Name="FK_Orders_Customers", Storage="_Customer", ThisKey="CustomerID", IsForeignKey=true)]
public Customer Customer
{
get
{
return this._Customer.Entity;
}
set
{
Customer previousValue = this._Customer.Entity;
if (((previousValue != value)
|| (this._Customer.HasLoadedOrAssignedValue == false)))
{
this.SendPropertyChanging();
if ((previousValue != null))
{
this._Customer.Entity = null;
previousValue.Orders.Remove(this);
}
this._Customer.Entity = value;
if ((value != null))
{
value.Orders.Add(this);
this._CustomerID = value.CustomerID;
}
else
{
this._CustomerID = default(string);
}
this.SendPropertyChanged("Customer");
}
}
}
<Association(Name:="FK_Orders_Customers", Storage:="_Customer", ThisKey:="CustomerID", IsForeignKey:=true)> _
Public Property Customer() As Customer
Get
Return Me._Customer.Entity
End Get
Set
Dim previousValue As Customer = Me._Customer.Entity
If (((previousValue Is value) _
= false) _
OrElse (Me._Customer.HasLoadedOrAssignedValue = false)) Then
Me.SendPropertyChanging
If ((previousValue Is Nothing) _
= false) Then
Me._Customer.Entity = Nothing
previousValue.Orders.Remove(Me)
End If
Me._Customer.Entity = value
If ((value Is Nothing) _
= false) Then
value.Orders.Add(Me)
Me._CustomerID = value.CustomerID
Else
Me._CustomerID = CType(Nothing, String)
End If
Me.SendPropertyChanged("Customer")
End If
End Set
End Property
Para obtener más información, consulta la sección relativa al atributo de asociación de Mapeo Basado en Atributos.
Métodos y procedimientos almacenados de base de datos en LINQ to SQL
LINQ to SQL admite los procedimientos almacenados y las funciones definidas por el usuario. En LINQ to SQL, estas abstracciones definidas por la base de datos se asignan a objetos de cliente de tal forma que se pueda acceder a ellos de manera fuertemente tipada desde el código de cliente. Las firmas de método guardan la máxima similitud con las firmas de los procedimientos y funciones que se definen en la base de datos. Puede utilizar IntelliSense para detectar estos métodos.
Un conjunto de resultados devuelto por una llamada a un procedimiento asignado es una colección fuertemente tipada.
LINQ to SQL asigna los procedimientos almacenados y las funciones a los métodos utilizando los atributos FunctionAttribute y ParameterAttribute. Los métodos que representan procedimientos almacenados se distinguen de los que representan funciones definidas por el usuario mediante la propiedad IsComposable. Si esta propiedad se establece en false (valor predeterminado), el método representa un procedimiento almacenado. Si se establece en true, el método representa una función de base de datos.
Nota:
Si usa Visual Studio, puede usar Object Relational Designer para crear métodos asignados a los procedimientos almacenados y funciones definidas por el usuario.
Ejemplo
// This is an example of a stored procedure in the Northwind
// sample database. The IsComposable property defaults to false.
[Function(Name="dbo.CustOrderHist")]
public ISingleResult<CustOrderHistResult> CustOrderHist([Parameter(Name="CustomerID", DbType="NChar(5)")] string customerID)
{
IExecuteResult result = this.ExecuteMethodCall(this, ((MethodInfo)(MethodInfo.GetCurrentMethod())), customerID);
return ((ISingleResult<CustOrderHistResult>)(result.ReturnValue));
}
' This is an example of a stored procedure in the Northwind
' sample database. The IsComposable property defaults to false.
<FunctionAttribute(Name:="dbo.CustOrderHist")> _
Public Function CustOrderHist(<Parameter(Name:="CustomerID", DbType:="NChar(5)")> ByVal customerID As String) As ISingleResult(Of CustOrderHistResult)
Dim result As IExecuteResult = Me.ExecuteMethodCall(Me, CType(MethodInfo.GetCurrentMethod, MethodInfo), customerID)
Return CType(result.ReturnValue, ISingleResult(Of CustOrderHistResult))
End Function
Para más información, consulte las secciones relativas a FunctionAttribute, StoredProcedureAttribute y ParameterAttribute de Asignación basada en atributos y Procedimientos almacenados.