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. Assim, as operações de dados são conduzidas de acordo com o modelo de objeto.
Neste 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. Se você quiser consultar o banco de dados ou enviar alterações para ele, o LINQ to SQL converterá suas solicitações em comandos SQL corretos e enviará esses comandos para o banco de dados.
Os elementos mais fundamentais no modelo de objeto do LINQ to SQL e sua relação com elementos no modelo de dados relacional estão resumidos na tabela a seguir:
| Modelo de objeto LINQ to SQL | Modelo de dados relacional |
|---|---|
| Classe de entidade | Tabela |
| Membro de classe | Coluna |
| Associação | Relação de chave estrangeira |
| Método | Função ou procedimento armazenado |
Observação
As descrições a seguir supõem que você tenha noções básicas sobre o modelo de dados relacionais e de suas regras.
Classes de entidade e tabelas de banco de dados LINK to SQL
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 pelo fato de que você anota a classe usando informações especiais que associam a classe a uma tabela de banco de dados. Para fazer essa anotação, adicione 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 as 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, atribua campos ou propriedades para representar colunas de banco de dados. Para essa finalidade, o LINQ to SQL define o atributo ColumnAttribute, 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 persistidos no banco de dados ou recuperados dele. Aqueles não declarados como colunas são considerados partes transitórias da lógica do aplicativo.
O atributo ColumnAttribute tem uma variedade de propriedades que é possível usar para personalizar esses membros que representam colunas (por exemplo, designando um membro como representante de uma coluna de chave primária). Para obter mais informações, confira a seção Atributo de Coluna do Mapeamento Baseado em Atributo.
Associações e relações de chave estrangeira de banco de dados LINK to SQL
No LINQ to SQL, você representa associações de bancos de dados (como relações entre chave estrangeira e chave primária) aplicando o atributo AssociationAttribute. No segmento de código a seguir, a classe Order contém uma propriedade Customer que tem um atributo AssociationAttribute. Essa propriedade e seu atributo fornecem a classe Order que tem uma relação com a classe Customer.
O exemplo de código a seguir mostra a propriedade Customer da classe Order.
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 e procedimentos armazenados de banco de dados LINQ to SQL
O LINQ to SQL dá suporte a procedimentos armazenados e a 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 de método são a mais possível similares às assinaturas dos procedimentos e das funções definidas no banco de dados. É possível 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 atributos FunctionAttribute e ParameterAttribute. Os métodos que representam procedimentos armazenados são diferentes daqueles que representam funções definidas pelo usuário pela propriedade IsComposable. Se essa propriedade for definida como false (padrão), o método representará um procedimento armazenado. Se ela for definida 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 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, confira as seções Atributo de Função, Atributo de Procedimento Armazenado e Atributo de Parâmetro de Mapeamento Baseado em Atributo e Procedimentos Armazenados.