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:
| Modelo de objeto LINQ to SQL | Modelo de dados relacionais |
|---|---|
| Classe de entidade | Table |
| Membro da turma | Column |
| Associação | Relação de chave estrangeira |
| Método | Procedimento armazenado ou função |
Nota
As descrições a seguir pressupõem que você tenha um conhecimento básico do modelo de dados relacional e das regras.
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.
Nota
Se você estiver usando o Visual Studio, você pode usar o Object Relational Designer 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 Mapeamento baseado em atributos e procedimentos armazenados.