Table<TEntity>.AttachAll Método

Definição

Namespace:

System.Data.Linq

Assembly:

System.Data.Linq.dll

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).

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.