Table<TEntity>.AttachAll Metod

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

Typparametrar

Parametrar

Kommentarer

Den här metoden kopplar alla entiteter av en samling till en ny DataContext. När en ny entitet är ansluten initieras uppskjutna inläsare för alla underordnade samlingar (till exempel EntitySet samlingar med entiteter från associerade tabeller). När SubmitChanges anropas placeras medlemmar i de underordnade samlingarna i ett Unmodified tillstånd. Om du vill uppdatera medlemmar i en underordnad samling måste du uttryckligen anropa Attach och ange den entiteten.

Mer information finns i Datahämtning och CUD-åtgärder i N-nivåprogram (LINQ till SQL).

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)

Typparametrar

Parametrar

Exempel

I följande exempel visas hur du kan uppdatera ett Order objekt på en annan DataContext instans. Exemplet förutsätter att du har en anslutning till en databas och har gjort en LINQ till SQL-fil för den (i det här fallet Northwind-exempeldatabasen).

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

I följande exempel har ett entitetsobjekt som ska bifogas en sekundärnyckelrelation med ett annat objekt och lagras i cacheminnet men är inte kopplat. När du anropar SubmitChangesChangeProcessor lägger åtgärden till en Insert åtgärd för alla objekt med sekundärnyckel. Detta är en bieffekt när en entitetsinstans återanvänds i en annan DataContext instans. Därför stöder LINQ till SQL inte återanvändning av objekt.

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

I följande exempel visas ett scenario där kund A har avbrutit alla beställningar och kund B har tagit över ägarskapet för dem. Du kan bifoga alla beställningar av kund A på samma gång.

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

Kommentarer

Den här metoden kopplar alla entiteter av en samling till DataContext i antingen ett ändrat eller omodifierat tillstånd. Om entiteten bifogas som ändrad måste den antingen deklarera en versionsmedlem eller inte delta i kontrollen av uppdateringskonflikter. Om cachelagringen är oförändrad antas entiteten representera det ursprungliga värdet. När du har anropat den här metoden kan entitetens fält ändras med annan information från klienten innan SubmitChanges anropas. Mer information finns i Datahämtning och CUD-åtgärder i N-nivåprogram (LINQ till SQL).

När en ny entitet är ansluten initieras uppskjutna inläsare för alla underordnade samlingar (till exempel EntitySet samlingar med entiteter från associerade tabeller). När SubmitChanges anropas placeras medlemmar i de underordnade samlingarna i ett Unmodified tillstånd. Om du vill uppdatera medlemmar i en underordnad samling måste du uttryckligen anropa Attach och ange den entiteten.