O modelo de objeto LINQ to SQL

No LINQ to SQL, um modelo de objeto expresso na linguagem de programação do desenvolvedor é mapeado para o modelo de dados de um banco de dados relacional. As operações nos dados são então conduzidas de acordo com o modelo de objeto.

Nesse cenário, você não emite comandos de banco de dados (por exemplo, INSERT) para o banco de dados. Em vez disso, você altera valores e executa métodos em seu modelo de objeto. Quando você deseja consultar o banco de dados ou enviá-lo alterações, o LINQ to SQL traduz suas solicitações nos comandos SQL corretos e envia esses comandos para o banco de dados.

Os elementos mais fundamentais no modelo de objeto LINQ to SQL e sua relação com elementos no modelo de dados relacional são resumidos na tabela a seguir:

Classes de entidade LINQ to SQL e tabelas de banco de dados

No LINQ to SQL, uma tabela de banco de dados é representada por uma classe de entidade. Uma classe de entidade é como qualquer outra classe que você possa criar, exceto que você anota a classe usando informações especiais que associam a classe a uma tabela de banco de dados. Você faz essa anotação adicionando um atributo personalizado (TableAttribute) à sua declaração de classe, como no exemplo a seguir:

Exemplo

[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

Somente instâncias de classes declaradas como tabelas (ou seja, classes de entidade) podem ser salvas no banco de dados.

Para obter mais informações, consulte a seção Atributo da tabela do mapeamento baseado em atributos.

Membros da classe LINQ to SQL e colunas de banco de dados

Além de associar classes a tabelas, você designa campos ou propriedades para representar colunas de banco de dados. Para este propósito, LINQ to SQL define o ColumnAttribute atributo, como no exemplo a seguir:

Exemplo

[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

Somente campos e propriedades mapeados para colunas são mantidos ou recuperados do banco de dados. Aqueles não declarados como colunas são considerados como partes transitórias da lógica do aplicativo.

O ColumnAttribute atributo tem uma variedade de propriedades que você pode usar para personalizar esses membros que representam colunas (por exemplo, designando um membro como representando uma coluna de chave primária). Para obter mais informações, consulte a seção Atributo de coluna do mapeamento baseado em atributos.

Associações LINQ to SQL e relações de chave estrangeira de banco de dados

No LINQ to SQL, você representa associações de banco de dados (como relações de chave estrangeira para chave primária) aplicando o AssociationAttribute atributo. No segmento de código a seguir, a Order classe contém uma Customer propriedade que tem um AssociationAttribute atributo. Essa propriedade e seu atributo fornecem à Order classe uma relação com a Customer classe.

O exemplo de código a seguir mostra a Customer propriedade da Order classe.

Exemplo

[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 obter mais informações, consulte a seção Atributo de associação do mapeamento baseado em atributos.

Métodos LINQ to SQL e procedimentos armazenados de banco de dados

O LINQ to SQL suporta procedimentos armazenados e funções definidas pelo usuário. No LINQ to SQL, você mapeia essas abstrações definidas pelo banco de dados para objetos cliente para que possa acessá-las de maneira fortemente tipada a partir do código do cliente. As assinaturas do método assemelham-se tanto quanto possível às assinaturas dos procedimentos e funções definidos na base de dados. Você pode usar o IntelliSense para descobrir esses métodos.

Um conjunto de resultados que é retornado por uma chamada para um procedimento mapeado é uma coleção fortemente tipada.

O LINQ to SQL mapeia procedimentos armazenados e funções para métodos usando os FunctionAttribute atributos e ParameterAttribute . Os métodos que representam procedimentos armazenados são distinguidos daqueles que representam funções definidas pelo IsComposable usuário pela propriedade. Se essa propriedade for definida como false (o padrão), o método representará um procedimento armazenado. Se estiver definido como true, o método representa uma função de banco de dados.

Exemplo

// 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 obter mais informações, consulte as seções Atributo de função, Atributo de procedimento armazenado e Atributo de parâmetro de Mapeamento baseado em atributos e procedimentos armazenados.

Consulte também

• Mapeamento baseado em atributos
• Informações gerais