Compartilhar via

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 realizadas 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 enviar alterações, o LINQ para SQL converte suas solicitações nos comandos SQL corretos e envia esses comandos para o banco de dados.

Captura de tela que mostra o Modelo de Objeto Linq.

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:

Modelo de objeto LINQ to SQL Modelo de dados relacionais
Classe de entidade Tabela
Membro de classe Coluna
Associação Relação de chave estrangeira
Método Procedimento armazenado ou função

Observação

As descrições a seguir pressupõem que você tenha um conhecimento básico do modelo de dados relacional e das regras.

LINQ to SQL: classes de entidade 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ê pode 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) à 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, confira a seção Atributo de Tabela do Mapeamento baseado em atributo.

Membros de classe e colunas de banco de dados LINK to SQL

Além de associar classes a tabelas, você designa campos ou propriedades para representar colunas de banco de dados. Para essa finalidade, 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 mapeadas para colunas são persistentes ou recuperadas do banco de dados. Essas não declaradas como colunas são consideradas 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, designar um membro como representando uma coluna de chave primária). Para obter mais informações, consulte a seção Atributo de Coluna do Attribute-Based Mapeamento.

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

No LINQ to SQL, você representa associações de banco de dados (como chave estrangeira a relações de 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 atributo.

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

O LINQ to SQL dá suporte a 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 acessá-los de uma maneira com forte tipo a partir do código cliente. As assinaturas do método se assemelham o mais próximo possível das assinaturas dos procedimentos e funções definidos no banco de dados. Você pode usar o IntelliSense para descobrir esses métodos.

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

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

Observação

Se você estiver usando o Visual Studio, poderá usar o Designer Relacional de Objetos para criar métodos mapeados para procedimentos armazenados e funções definidas pelo usuário.

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 Attribute-Based mapeamento e procedimentos armazenados.

Consulte também