Modelo de objetos de LINQ to SQL

Actualización: November 2007

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 desarrollador. 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:

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:

Código de

<Table(Name:="Customers")> _
Public Class Customer
    Public CustomerID As String
    ' ...
    Public City As String
End Class

[Table(Name = "Customers")]
public class Customerzz
{
    public string CustomerID;
    // ...
    public string City;
}

Sólo las instancias de clases declaradas como tablas (es decir, clases de entidad) pueden guardarse en la base de datos.

Para obtener más información, vea la sección relativa al atributo de tabla del tema Asignación basada en atributos (LINQ to SQL).

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:

Código de

<Table(Name:="Customers")> _
Public Class Customer
    <Column(IsPrimaryKey:=True)> _
    Public CustomerID As String

    <Column()> _
    Public City As String
End Class

[Table(Name = "Customers")]
public class Customer
{
    [Column(IsPrimaryKey = true)]
    public string CustomerID;
    [Column]
    public string City;
}

Sólo 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 obtener más información, vea la sección relativa al atributo de columna del tema Asignación basada en atributos (LINQ to SQL).

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.

Código de

  <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

 [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");
            }
        }
    }

Para obtener más información, vea la sección relativa al atributo de asociación del tema Asignación basada en atributos (LINQ to SQL).

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 tener acceso a ellos con establecimiento inflexible de tipos 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 con establecimiento inflexible de tipos.

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:
En Visual Studio, puede utilizar el Diseñador relacional de objetos para crear métodos asignados a procedimientos almacenados y funciones definidas por el usuario.

Código de

   ' 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

    // 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));
    }

Para obtener más información, vea las secciones relativas a los atributos de función, de procedimiento almacenado y de parámetro en los temas Asignación basada en atributos (LINQ to SQL) y Procedimientos almacenados (LINQ to SQL).

Vea también

Referencia

Asignación basada en atributos (LINQ to SQL)

Otros recursos

Información general (LINQ to SQL)