Table<TEntity>.AttachAll Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Anexa todas as entidades de uma coleção ao DataContext em um estado inalterado ou modificado.
Sobrecargas
AttachAll<TSubEntity>(IEnumerable<TSubEntity>) |
Anexa todas as entidades de uma coleção ao DataContext em um estado inalterado ou modificado. |
AttachAll<TSubEntity>(IEnumerable<TSubEntity>, Boolean) |
Anexa todas as entidades de uma coleção ao DataContext em um estado inalterado ou modificado. |
Comentários
Se a anexação for modificada, a entidade deverá declarar um membro de versão ou não deve participar da verificação de conflitos de atualização.
Quando uma nova entidade é anexada, carregadores adiados para qualquer coleção filho (por exemplo, EntitySet
coleções de entidades de tabelas associadas) são inicializados. Quando SubmitChanges é chamado, os membros das coleções filho são colocados em um Unmodified
estado. Para atualizar os membros de uma coleção filho, você deve chamar Attach
explicitamente e especificar essa entidade.
Para ter mais informações, consulte Recuperação de dados e operações de CUD em aplicativos de N Camadas (LINQ to SQL).
AttachAll<TSubEntity>(IEnumerable<TSubEntity>)
Anexa todas as entidades de uma coleção ao DataContext em um estado inalterado ou modificado.
public:
generic <typename TSubEntity>
where TSubEntity : TEntity void AttachAll(System::Collections::Generic::IEnumerable<TSubEntity> ^ entities);
public void AttachAll<TSubEntity> (System.Collections.Generic.IEnumerable<TSubEntity> entities) where TSubEntity : TEntity;
member this.AttachAll : seq<#'Entity> -> unit
Public Sub AttachAll(Of TSubEntity As TEntity) (entities As IEnumerable(Of TSubEntity))
Parâmetros de tipo
- TSubEntity
O tipo de entidade a serem anexadas.
Parâmetros
- entities
- IEnumerable<TSubEntity>
A coleção de entidades.
Comentários
Esse método anexa todas as entidades de uma coleção a um novo DataContext. Quando uma nova entidade é anexada, carregadores adiados para qualquer coleção filho (por exemplo, EntitySet
coleções de entidades de tabelas associadas) são inicializados. Quando SubmitChanges é chamado, os membros das coleções filho são colocados em um Unmodified
estado. Para atualizar os membros de uma coleção filho, você deve chamar Attach
explicitamente e especificar essa entidade.
Para ter mais informações, consulte Recuperação de dados e operações de CUD em aplicativos de N Camadas (LINQ to SQL).
Aplica-se a
AttachAll<TSubEntity>(IEnumerable<TSubEntity>, Boolean)
Anexa todas as entidades de uma coleção ao DataContext em um estado inalterado ou modificado.
public:
generic <typename TSubEntity>
where TSubEntity : TEntity void AttachAll(System::Collections::Generic::IEnumerable<TSubEntity> ^ entities, bool asModified);
public void AttachAll<TSubEntity> (System.Collections.Generic.IEnumerable<TSubEntity> entities, bool asModified) where TSubEntity : TEntity;
member this.AttachAll : seq<#'Entity> * bool -> unit
Public Sub AttachAll(Of TSubEntity As TEntity) (entities As IEnumerable(Of TSubEntity), asModified As Boolean)
Parâmetros de tipo
- TSubEntity
O tipo de entidade a serem anexadas.
Parâmetros
- entities
- IEnumerable<TSubEntity>
A coleção de entidades.
- asModified
- Boolean
true
se o objeto tiver um membro RowVersion ou um carimbo de data/hora, false
se os valores estiverem sendo usados para a verificação de simultaneidade otimista.
Exemplos
O exemplo a seguir mostra como você pode atualizar um Order
objeto em uma instância diferente DataContext . O exemplo pressupõe que você tenha uma conexão com um banco de dados e tenha feito um arquivo LINQ to SQL para ele (nesse caso, o banco de dados de exemplo Northwind).
using (Northwnd db = new Northwnd(@"c:\northwnd.mdf"))
{
// Get original Customer from deserialization.
var q1 = db.Orders.First();
string serializedQ = SerializeHelper.Serialize(q1);
var q2 = SerializeHelper.Deserialize(serializedQ, q1);
// Track this object for an update (not insert).
db.Orders.Attach(q2, false);
// Replay the changes.
q2.ShipRegion = "King";
q2.ShipAddress = "1 Microsoft Way";
// DataContext knows how to update the order.
db.SubmitChanges();
}
Using db As New Northwnd("")
' Get original Customer from deserialization.
Dim q1 = db.Orders.First()
Dim serializedQ As String = SerializeHelper.Serialize(q1)
Dim q2 = SerializeHelper.Deserialize(serializedQ, q1)
' Track this object for an update (not insert).
db.Orders.Attach(q2, False)
' Replay the changes.
q2.ShipRegion = "King"
q2.ShipAddress = "1 Microsoft Way"
' DataContext knows how to update the order.
db.SubmitChanges()
End Using
No exemplo a seguir, um objeto de entidade a ser anexado tem uma relação de chave estrangeira com outro objeto e é armazenado no cache, mas não anexado. Quando você chama SubmitChanges, o ChangeProcessor
adiciona uma Insert
operação para todos os objetos de chave estrangeira. Esse é um efeito colateral quando uma instância de entidade é usada novamente em uma instância diferente DataContext . Por esse motivo, LINQ to SQL não dá suporte ao reutilizações de objetos.
Customer c = null;
using (Northwnd db = new Northwnd(""))
{
/* Get both the customer c and the customer's order
into the cache. */
c = db.Customers.First();
string sc = c.Orders.First().ShipCity;
}
using (Northwnd nw2 = new Northwnd(""))
{
// Attach customers and update the address.
nw2.Customers.Attach(c, false);
c.Address = "new";
nw2.Log = Console.Out;
/* At SubmitChanges, you will see INSERT requests for all
Customer c’s orders. */
nw2.SubmitChanges();
}
Sub method7()
Dim c As Customer = Nothing
Using db = New Northwnd("...")
' Get both the customer c and the customer's order
' into the cache.
c = db.Customers.First()
Dim sc = c.Orders.First().ShipCity
End Using
Using nw2 = New Northwnd("...")
' Attach customers and update the address.
nw2.Customers.Attach(c, False)
c.Address = "new"
nw2.Log = Console.Out
' At SubmitChanges, you will see INSERT requests for all
' c's orders.
nw2.SubmitChanges()
End Using
O exemplo a seguir mostra um cenário no qual o Cliente A cancelou todos os pedidos e o Cliente B assumiu a propriedade deles. Você pode anexar todos os pedidos do Cliente A ao mesmo tempo.
Customer CustA_File = new Customer();
Customer CustB_File = new Customer();
string xmlFileA = "";
string xmlFileB = "";
// Get the serialized objects.
Customer A = SerializeHelper.Deserialize<Customer>(xmlFileA, CustA_File);
Customer B = SerializeHelper.Deserialize<Customer>(xmlFileB, CustB_File);
List<Order> AOrders = A.Orders.ToList();
using (Northwnd db = new Northwnd(@"c:\northwnd.mdf"))
{
//Attach all the orders belonging to Customer A all at once.
db.Orders.AttachAll(AOrders, false);
// Update the orders belonging to Customer A to show them
// as owned by Customer B.
foreach (Order o in AOrders)
{
o.CustomerID = B.CustomerID;
}
// DataContext can now apply the change of ownership to
// the database.
db.SubmitChanges();
}
Dim custA_File = New Customer()
Dim custB_File = New Customer()
Dim xmlFileA As String = ""
Dim xmlFileB As String = ""
' Get the serialized objects.
Dim A As Customer = SerializeHelper.Deserialize(Of Customer)(xmlFileA, custA_File)
Dim B As Customer = SerializeHelper.Deserialize(Of Customer)(xmlFileB, custB_File)
Dim AOrders As List(Of Order) = A.Orders.ToList()
Using db As New Northwnd("...")
'Attach all the orders belonging to Customer A all at once.
db.Orders.AttachAll(AOrders, False)
' Update the orders belonging to Customer A to show them
' as owned by Customer B
For Each o In AOrders
o.CustomerID = B.CustomerID
Next
' DataContext can now apply the change of ownership to
'the database
db.SubmitChanges()
End Using
Comentários
Esse método anexa todas as entidades de uma coleção ao DataContext em um estado modificado ou não modificado . Se a anexação for modificada, a entidade deverá declarar um membro de versão ou não deve participar da verificação de conflitos de atualização. Se estiver anexando como não modificada, a entidade será assumida para representar o valor original. Depois de chamar esse método, os campos da entidade podem ser modificados com outras informações do cliente antes SubmitChanges de serem chamados. Para ter mais informações, consulte Recuperação de dados e operações de CUD em aplicativos de N Camadas (LINQ to SQL).
Quando uma nova entidade é anexada, carregadores adiados para qualquer coleção filho (por exemplo, EntitySet
coleções de entidades de tabelas associadas) são inicializados. Quando SubmitChanges é chamado, os membros das coleções filho são colocados em um Unmodified
estado. Para atualizar os membros de uma coleção filho, você deve chamar Attach
explicitamente e especificar essa entidade.