Partager via

Table<TEntity>.AttachAll Méthode

  • Référence

Définition

Espace de noms:
System.Data.Linq
Assembly:
System.Data.Linq.dll

Attache toutes les entités d'une collection à la classe DataContext dans un état modifié ou non modifié.

Surcharges

AttachAll<TSubEntity>(IEnumerable<TSubEntity>)

Attache toutes les entités d'une collection à la classe DataContext dans un état modifié ou non modifié.
AttachAll<TSubEntity>(IEnumerable<TSubEntity>, Boolean)

Attache toutes les entités d'une collection à la classe DataContext dans un état modifié ou non modifié.

Remarques

Si l’attachement est modifié, l’entité doit déclarer un membre de version ou ne doit pas participer à la vérification des conflits de mise à jour.

Lorsqu’une nouvelle entité est attachée, les chargeurs différés pour les collections enfants (par exemple, EntitySet les collections d’entités des tables associées) sont initialisés. Quand SubmitChanges est appelé, les membres des collections enfants sont placés dans un Unmodified état. Pour mettre à jour les membres d’une collection enfant, vous devez appeler Attach et spécifier explicitement cette entité.

Pour plus d’informations, consultez Récupération de données et opérations CUD dans les applications multiniveaux (LINQ to SQL).

AttachAll<TSubEntity>(IEnumerable<TSubEntity>)

Attache toutes les entités d'une collection à la classe DataContext dans un état modifié ou non modifié.

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

Paramètres de type

TSubEntity

Type d'entités à joindre.

Paramètres

entities
IEnumerable<TSubEntity>

Collection d'entités.

Remarques

Cette méthode attache toutes les entités d’une collection à un nouveau DataContext. Lorsqu’une nouvelle entité est attachée, les chargeurs différés pour les collections enfants (par exemple, EntitySet les collections d’entités des tables associées) sont initialisés. Quand SubmitChanges est appelé, les membres des collections enfants sont placés dans un Unmodified état. Pour mettre à jour les membres d’une collection enfant, vous devez appeler Attach et spécifier explicitement cette entité.

Pour plus d’informations, consultez Récupération de données et opérations CUD dans les applications multiniveaux (LINQ to SQL).

S’applique à

AttachAll<TSubEntity>(IEnumerable<TSubEntity>, Boolean)

Attache toutes les entités d'une collection à la classe DataContext dans un état modifié ou non modifié.

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)

Paramètres de type

TSubEntity

Type d'entités à joindre.

Paramètres

entities
IEnumerable<TSubEntity>

Collection d'entités.

asModified
Boolean

true si l'objet est horodaté ou dispose d'un membre RowVersion ; false si les valeurs d'origine sont utilisées pour le contrôle d'accès concurrentiel.

Exemples

L’exemple suivant montre comment mettre à jour un Order objet sur un autre DataContext instance. L’exemple suppose que vous disposez d’une connexion à une base de données et que vous avez créé un fichier LINQ to SQL pour celle-ci (dans ce cas, l’exemple de base de données 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

Dans l’exemple suivant, un objet d’entité à attacher a une relation de clé étrangère avec un autre objet et est stocké dans le cache, mais pas attaché. Lorsque vous appelez SubmitChanges, ajoute ChangeProcessor une Insert opération pour tous les objets de clé étrangère. Il s’agit d’un effet secondaire lorsqu’une entité instance est réutilisée dans un autre DataContext instance. Pour cette raison, LINQ to SQL ne prend pas en charge la réutilisation des objets.

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

L’exemple suivant montre un scénario dans lequel le client A a annulé toutes les commandes et où le client B en a pris possession. Vous pouvez joindre toutes les commandes du client A en même temps.

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

Remarques

Cette méthode attache toutes les entités d’une collection à l’état DataContextmodifié ou non modifié . Si l’attachement est modifié, l’entité doit déclarer un membre de version ou ne doit pas participer à la vérification des conflits de mise à jour. Si l’attachement est non modifié, l’entité est supposée représenter la valeur d’origine. Après avoir appelé cette méthode, les champs de l’entité peuvent être modifiés avec d’autres informations du client avant SubmitChanges d’être appelés. Pour plus d’informations, consultez Récupération de données et opérations CUD dans les applications multiniveaux (LINQ to SQL).

Lorsqu’une nouvelle entité est attachée, les chargeurs différés pour les collections enfants (par exemple, EntitySet les collections d’entités des tables associées) sont initialisés. Quand SubmitChanges est appelé, les membres des collections enfants sont placés dans un Unmodified état. Pour mettre à jour les membres d’une collection enfant, vous devez appeler Attach et spécifier explicitement cette entité.

S’applique à