El modelo de objetos LINQ to SQL

En LINQ to SQL, un modelo de objetos expresado en el lenguaje de programación del desarrollador se asigna al modelo de datos de una base de datos relacional. Después, las operaciones de los datos se realizan según el modelo de objetos.

En este escenario, no emite comandos de base de datos (por ejemplo, INSERT) a la base de datos. En su lugar, se cambian los valores y se ejecutan métodos dentro del modelo de objetos. Cuando desee consultar la base de datos o enviar los cambios, LINQ to SQL traduce las solicitudes en los comandos SQL correctos y los envía a la base de datos.

Los elementos más fundamentales del modelo de objetos LINQ to SQL y su relación con los elementos del modelo de datos relacionales se resumen en la tabla siguiente:

Clases de entidad y tablas de base de datos 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 similar a cualquier otra clase que pueda crear, excepto que anota la clase mediante información especial que asocia la clase a una tabla de base de datos. Para realizar esta anotación, agregue 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 se pueden guardar en la base de datos instancias de clases declaradas como tablas (es decir, clases de entidad).

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 con tablas, designa campos o propiedades para representar columnas de base de datos. Para ello, LINQ to SQL define el ColumnAttribute atributo , 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 propiedades asignados a columnas se conservan en la base de datos o se recuperan de ella. Los que no se declaran como columnas se consideran partes transitorias de la lógica de la aplicación.

El ColumnAttribute atributo tiene una variedad de propiedades que puede usar para personalizar estos miembros que representan columnas (por ejemplo, designando un miembro como representando 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, representas las asociaciones de bases de datos (como las relaciones de clave externa a clave principal) aplicando el atributo AssociationAttribute. En el siguiente segmento de código, la Order clase contiene una Customer propiedad que tiene un AssociationAttribute atributo . Esta propiedad y su atributo proporcionan a la Order clase una relación con la Customer clase .

En el ejemplo de código siguiente se muestra la Customer propiedad de la Order clase .

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 LINQ to SQL y procedimientos almacenados en la base de datos

LINQ to SQL admite procedimientos almacenados y 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 se asemejan tanto como sea posible a las firmas de los procedimientos y funciones definidos en la base de datos. Puede usar 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 procedimientos almacenados y funciones a métodos mediante los FunctionAttribute atributos y ParameterAttribute . Los métodos que representan procedimientos almacenados se distinguen de los que representan funciones definidas por el usuario por la IsComposable propiedad . 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.

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.

Consulte también

• Asignación basada en atributos
• Información de fondo