DataTable.Merge Metoda

Zdroj:

DataTable.cs

Zdroj:

DataTable.cs

Zdroj:

DataTable.cs

public:
 void Merge(System::Data::DataTable ^ table, bool preserveChanges, System::Data::MissingSchemaAction missingSchemaAction);

public void Merge (System.Data.DataTable table, bool preserveChanges, System.Data.MissingSchemaAction missingSchemaAction);

member this.Merge : System.Data.DataTable * bool * System.Data.MissingSchemaAction -> unit

Public Sub Merge (table As DataTable, preserveChanges As Boolean, missingSchemaAction As MissingSchemaAction)

Parametry

Příklady

Následující konzolová aplikace demonstruje chování missingSchemaAction parametru Merge metody. Tento příklad vytvoří dvě verze stejné tabulky a upraví schéma pro druhou verzi. Kód se pak pokusí sloučit druhou tabulku s první.

private static void DemonstrateMergeTable()
{
    DataTable itemsTable = new DataTable("Items");

    // Add columns
    DataColumn idColumn = new DataColumn("id", typeof(System.Int32));
    DataColumn itemColumn = new DataColumn("item", typeof(System.Int32));
    itemsTable.Columns.Add(idColumn);
    itemsTable.Columns.Add(itemColumn);

    // Set the primary key column.
    itemsTable.PrimaryKey = new DataColumn[] { idColumn };

    // Add RowChanged event handler for the table.
    itemsTable.RowChanged +=
        new System.Data.DataRowChangeEventHandler(Row_Changed);

    // Add ten rows.
    DataRow row;
    for (int i = 0; i <= 9; i++)
    {
        row = itemsTable.NewRow();
        row["id"] = i;
        row["item"] = i;
        itemsTable.Rows.Add(row);
    }

    // Accept changes.
    itemsTable.AcceptChanges();
    PrintValues(itemsTable, "Original values");

    // Create a second DataTable identical to the first.
    DataTable itemsClone = itemsTable.Clone();

    // Add column to the second column, so that the
    // schemas no longer match.
    itemsClone.Columns.Add("newColumn", typeof(System.String));

    // Add three rows. Note that the id column can't be the
    // same as existing rows in the original table.
    row = itemsClone.NewRow();
    row["id"] = 14;
    row["item"] = 774;
    row["newColumn"] = "new column 1";
    itemsClone.Rows.Add(row);

    row = itemsClone.NewRow();
    row["id"] = 12;
    row["item"] = 555;
    row["newColumn"] = "new column 2";
    itemsClone.Rows.Add(row);

    row = itemsClone.NewRow();
    row["id"] = 13;
    row["item"] = 665;
    row["newColumn"] = "new column 3";
    itemsClone.Rows.Add(row);

    // Merge itemsClone into the itemsTable.
    Console.WriteLine("Merging");
    itemsTable.Merge(itemsClone, false, MissingSchemaAction.Add);
    PrintValues(itemsTable, "Merged With itemsTable, schema added");
}

private static void Row_Changed(object sender,
    DataRowChangeEventArgs e)
{
    Console.WriteLine("Row changed {0}\t{1}",
        e.Action, e.Row.ItemArray[0]);
}

private static void PrintValues(DataTable table, string label)
{
    // Display the values in the supplied DataTable:
    Console.WriteLine(label);
    foreach (DataRow row in table.Rows)
    {
        foreach (DataColumn col in table.Columns)
        {
            Console.Write("\t " + row[col].ToString());
        }
        Console.WriteLine();
    }
}

Private Sub DemonstrateMergeTable()
  Dim itemsTable As New DataTable("Items")

  ' Add columns
  Dim idColumn As New DataColumn("id", GetType(System.Int32))
  Dim itemColumn As New DataColumn("item", GetType(System.Int32))
  itemsTable.Columns.Add(idColumn)
  itemsTable.Columns.Add(itemColumn)

  ' Set the primary key column.
  itemsTable.PrimaryKey = New DataColumn() {idColumn}

  ' Add RowChanged event handler for the table.
  AddHandler itemsTable.RowChanged, AddressOf Row_Changed

  ' Add some rows.
  Dim row As DataRow
  For i As Integer = 0 To 3
    row = itemsTable.NewRow()
    row("id") = i
    row("item") = i
    itemsTable.Rows.Add(row)
  Next i

  ' Accept changes.
  itemsTable.AcceptChanges()
  PrintValues(itemsTable, "Original values")

  ' Create a second DataTable identical to the first.
  Dim itemsClone As DataTable = itemsTable.Clone()

  ' Add column to the second column, so that the 
  ' schemas no longer match.
  itemsClone.Columns.Add("newColumn", GetType(System.String))

  ' Add three rows. Note that the id column can't be the 
  ' same as existing rows in the original table.
  row = itemsClone.NewRow()
  row("id") = 14
  row("item") = 774
  row("newColumn") = "new column 1"
  itemsClone.Rows.Add(row)

  row = itemsClone.NewRow()
  row("id") = 12
  row("item") = 555
  row("newColumn") = "new column 2"
  itemsClone.Rows.Add(row)

  row = itemsClone.NewRow()
  row("id") = 13
  row("item") = 665
  row("newColumn") = "new column 3"
  itemsClone.Rows.Add(row)

  ' Merge itemsClone into the itemsTable.
  Console.WriteLine("Merging")
  itemsTable.Merge(itemsClone, False, MissingSchemaAction.Add)
  PrintValues(itemsTable, "Merged With itemsTable, Schema added")
End Sub

Private Sub Row_Changed(ByVal sender As Object, _
  ByVal e As DataRowChangeEventArgs)
  Console.WriteLine("Row changed {0}{1}{2}", _
    e.Action, ControlChars.Tab, e.Row.ItemArray(0))
End Sub

Private Sub PrintValues(ByVal table As DataTable, ByVal label As String)
  ' Display the values in the supplied DataTable:
  Console.WriteLine(label)
  For Each row As DataRow In table.Rows
    For Each col As DataColumn In table.Columns
      Console.Write(ControlChars.Tab + " " + row(col).ToString())
    Next col
    Console.WriteLine()
  Next row
End Sub

Poznámky

Metoda Merge se používá ke sloučení dvou DataTable objektů, které mají do značné míry podobná schémata. Sloučení se obvykle používá v klientské aplikaci k začlenění nejnovějších změn ze zdroje dat do existujícího DataTable. To umožňuje klientské aplikaci aktualizovat DataTable nejnovějšími daty ze zdroje dat.

Operace sloučení bere v úvahu pouze původní tabulku a tabulku, která se má sloučit. Podřízené tabulky nejsou ovlivněny ani zahrnuty. Pokud má tabulka jednu nebo více podřízených tabulek definovaných jako součást relace, musí být každá podřízená tabulka sloučena samostatně.

Metoda se Merge obvykle volá na konci řady procedur, které zahrnují ověření změn, odsouhlasení chyb, aktualizaci zdroje dat pomocí změn a nakonec aktualizaci existujícího DataTableobjektu .

Při provádění sloučení se změny provedené v existujících datech před sloučením zachovají během operace sloučení, pokud vývojář pro preserveChanges parametr nezadá hodnotu false. preserveChanges Pokud je parametr nastavený na true, příchozí hodnoty nepřepíšou existující hodnoty v aktuální verzi řádku existujícího řádku. preserveChanges Pokud je parametr nastavený na false, příchozí hodnoty přepíšou existující hodnoty v aktuální verzi řádku existujícího řádku. Další informace o verzích řádků najdete v tématu Stavy řádků a Verze řádků.

V klientské aplikaci je obvyklé, že uživatel může kliknout na jediné tlačítko, které shromáždí změněná data a ověří je před odesláním zpět do komponenty střední vrstvy. V tomto scénáři GetChanges je nejprve vyvolána metoda. Tato metoda vrátí sekundu DataTable optimalizovanou pro ověřování a slučování. Tento druhý DataTable objekt obsahuje pouze DataTable objekty a DataRow , které byly změněny, což vede k podmnožině původního DataTableobjektu . Tato podmnožina je obecně menší, a proto se tato podmnožina efektivněji předává zpět do komponenty střední vrstvy. Komponenta střední vrstvy pak aktualizuje původní zdroj dat o změny prostřednictvím uložených procedur. Střední vrstva pak může odeslat zpět buď novou DataTable , která obsahuje původní data a nejnovější data ze zdroje dat (opětovným spuštěním původního dotazu), nebo může odeslat zpět podmnožinu se všemi změnami, které byly provedeny ze zdroje dat. (Pokud například zdroj dat automaticky vytvoří jedinečné hodnoty primárního klíče, je možné tyto hodnoty rozšířit zpět do klientské aplikace.) V obou případech je možné vrácenou DataTable metodou sloučit zpět do původní DataTableMerge klientské aplikace.

Při zavolání Merge metody jsou porovnány schémata dvou DataTable objektů, protože je možné, že schémata byla změněna. Například v případě komunikace mezi dvěma společnostmi mohly být v rámci automatizovaného procesu přidány nové sloupce do schématu XML. Pokud zdroj DataTable obsahuje prvky schématu (přidané DataColumn objekty), které chybí v cíli, lze elementy schématu přidat do cíle nastavením argumentu missingSchemaAction na MissingSchemaAction.Addhodnotu . V takovém případě sloučené DataTable obsahuje přidané schéma a data.

Po sloučení schémat se sloučí data.

Při slučování nového zdroje DataTable do cíle se všechny zdrojové řádky s DataRowState hodnotou Unchanged, Modifiednebo Deleted shodují s cílovými řádky se stejnými hodnotami primárního klíče. Zdrojové řádky s DataRowState hodnotou jsou Added spárovány s novými cílovými řádky se stejnými hodnotami primárního klíče jako nové zdrojové řádky.

Viz také

• Datové tabulky
• Zpracování událostí datové tabulky

Zdroj:

DataTable.cs

Zdroj:

DataTable.cs

Zdroj:

DataTable.cs

public:
 void Merge(System::Data::DataTable ^ table, bool preserveChanges);

public void Merge (System.Data.DataTable table, bool preserveChanges);

member this.Merge : System.Data.DataTable * bool -> unit

Public Sub Merge (table As DataTable, preserveChanges As Boolean)

Parametry

Příklady

Následující konzolová DataTable aplikace vytvoří řádky obsahující, upraví některá data v těchto řádcích a pokusí se sloučit data z jiného DataTableobjektu . Příklad ukazuje různé chování parametru preserveChanges .

private static void DemonstrateMergeTable()
{
    // Demonstrate merging, within and without
    // preserving changes.

    // In this example, take these actions:
    // 1. Create a DataTable (table1) and fill the table with data.
    // 2. Create a copy of table1, and modify its data (modifiedTable).
    // 3. Modify data in table1.
    // 4. Make a copy of table1 (table1Copy).
    // 5. Merge the data from modifiedTable into table1 and table1Copy,
    //    showing the difference between setting the preserveChanges
    //    parameter to true and false.

    // Create a new DataTable.
    DataTable table1 = new DataTable("Items");

    // Add two columns to the table:
    DataColumn column = new DataColumn("id", typeof(System.Int32));
    column.AutoIncrement = true;
    table1.Columns.Add(column);

    column = new DataColumn("item", typeof(System.String));
    table1.Columns.Add(column);

    // Set primary key column.
    table1.PrimaryKey = new DataColumn[] { table1.Columns[0] };

    // Add some rows.
    DataRow row;
    for (int i = 0; i <= 3; i++)
    {
        row = table1.NewRow();
        row["item"] = "Item " + i;
        table1.Rows.Add(row);
    }

    // Accept changes.
    table1.AcceptChanges();
    PrintValues(table1, "Original values");

    // Using the same schema as the original table,
    // modify the data for later merge.
    DataTable modifiedTable = table1.Copy();
    foreach (DataRow rowModified in modifiedTable.Rows)
    {
        rowModified["item"] = rowModified["item"].ToString()
            + " modified";
    }
    modifiedTable.AcceptChanges();

    // Change row values, and add a new row:
    table1.Rows[0]["item"] = "new Item 0";
    table1.Rows[1]["item"] = "new Item 1";

    row = table1.NewRow();
    row["id"] = 4;
    row["item"] = "Item 4";
    table1.Rows.Add(row);

    // Get a copy of the modified data:
    DataTable table1Copy = table1.Copy();
    PrintValues(table1, "Modified and new Values");
    PrintValues(modifiedTable, "Data to be merged into table1");

    // Merge new data into the modified data.
    table1.Merge(modifiedTable, true);
    PrintValues(table1, "Merged data (preserve changes)");

    table1Copy.Merge(modifiedTable, false);
    PrintValues(table1Copy, "Merged data (don't preserve changes)");
}

private static void PrintValues(DataTable table, string label)
{
    // Display the values in the supplied DataTable:
    Console.WriteLine(label);
    foreach (DataRow row in table.Rows)
    {
        foreach (DataColumn column in table.Columns)
        {
            Console.Write("\t{0}", row[column, DataRowVersion.Current]);
        }
        Console.WriteLine();
    }
}

Private Sub DemonstrateMergeTable()
  ' Demonstrate merging, within and without
  ' preserving changes.

  ' In this example, take these actions:
  ' 1. Create a DataTable (table1) and fill the table with data.
  ' 2. Create a copy of table1, and modify its data (modifiedTable).
  ' 3. Modify data in table1.
  ' 4. Make a copy of table1 (table1Copy).
  ' 5. Merge the data from modifiedTable into table1 and table1Copy, 
  '    showing the difference between setting the preserveChanges 
  '    parameter to true and false.

  ' Create a new DataTable.
  Dim table1 As New DataTable("Items")

  ' Add two columns to the table:
  Dim column As New DataColumn("id", GetType(System.Int32))
  column.AutoIncrement = True
  table1.Columns.Add(column)

  column = New DataColumn("item", GetType(System.String))
  table1.Columns.Add(column)

  ' Set primary key column.
  table1.PrimaryKey = New DataColumn() {table1.Columns(0)}

  ' Add some rows.
  Dim row As DataRow
  For i As Integer = 0 To 3
    row = table1.NewRow()
    row("item") = "Item " & i
    table1.Rows.Add(row)
  Next i

  ' Accept changes.
  table1.AcceptChanges()
  PrintValues(table1, "Original values")

  ' Using the same schema as the original table, 
  ' modify the data for later merge.
  Dim modifiedTable As DataTable = table1.Copy()
  For Each row In modifiedTable.Rows
    row("item") = row("item").ToString() & " modified"
  Next
  modifiedTable.AcceptChanges()

  ' Change row values, and add a new row:
  table1.Rows(0)("item") = "New Item 0"
  table1.Rows(1)("item") = "New Item 1"

  row = table1.NewRow()
  row("id") = 4
  row("item") = "Item 4"
  table1.Rows.Add(row)

  ' Get a copy of the modified data:
  Dim table1Copy As DataTable = table1.Copy()
  PrintValues(table1, "Modified and New Values")
  PrintValues(modifiedTable, "Data to be merged into table1")


  ' Merge new data into the modified data.
  table1.Merge(modifiedTable, True)
  PrintValues(table1, "Merged data (preserve changes)")

  table1Copy.Merge(modifiedTable, False)
  PrintValues(table1Copy, "Merged data (don't preserve changes)")

End Sub

Private Sub PrintValues(ByVal table As DataTable, _
  ByVal label As String)

  ' Display the values in the supplied DataTable:
  Console.WriteLine(label)
  For Each row As DataRow In table.Rows
    For Each column As DataColumn In table.Columns
      Console.Write("{0}{1}", ControlChars.Tab, row(column, _
          DataRowVersion.Current))
    Next column
    Console.WriteLine()
  Next row
End Sub

Poznámky

Metoda Merge se používá ke sloučení dvou DataTable objektů, které mají do značné míry podobná schémata. Sloučení se obvykle používá v klientské aplikaci k začlenění nejnovějších změn ze zdroje dat do existujícího DataTable. To umožňuje klientské aplikaci aktualizovat DataTable nejnovějšími daty ze zdroje dat.

Operace sloučení bere v úvahu pouze původní tabulku a tabulku, která se má sloučit. Podřízené tabulky nejsou ovlivněny ani zahrnuty. Pokud má tabulka jednu nebo více podřízených tabulek definovaných jako součást relace, musí být každá podřízená tabulka sloučena samostatně.

Metoda se Merge obvykle volá na konci řady procedur, které zahrnují ověření změn, odsouhlasení chyb, aktualizaci zdroje dat pomocí změn a nakonec aktualizaci existujícího DataTableobjektu .

Při provádění sloučení se změny provedené v existujících datech před sloučením zachovají během operace sloučení, pokud vývojář pro preserveChanges parametr nezadá hodnotu false. preserveChanges Pokud je parametr nastavený na true, příchozí hodnoty nepřepíšou existující hodnoty v aktuální verzi řádku existujícího řádku. preserveChanges Pokud je parametr nastavený na false, příchozí hodnoty přepíšou existující hodnoty v aktuální verzi řádku existujícího řádku. Další informace o verzích řádků najdete v tématu Stavy řádků a Verze řádků.

V klientské aplikaci je obvyklé, že uživatel může kliknout na jediné tlačítko, které shromáždí změněná data a ověří je před odesláním zpět do komponenty střední vrstvy. V tomto scénáři GetChanges je nejprve vyvolána metoda. Tato metoda vrátí sekundu DataTable optimalizovanou pro ověřování a slučování. Tento druhý DataTable objekt obsahuje pouze DataTable objekty a DataRow , které byly změněny, což vede k podmnožině původního DataTableobjektu . Tato podmnožina je obecně menší, a proto se tato podmnožina efektivněji předává zpět do komponenty střední vrstvy. Komponenta střední vrstvy pak aktualizuje původní zdroj dat o změny prostřednictvím uložených procedur. Střední vrstva pak může odeslat zpět buď novou DataTable , která obsahuje původní data a nejnovější data ze zdroje dat (opětovným spuštěním původního dotazu), nebo může odeslat zpět podmnožinu se všemi změnami, které byly provedeny ze zdroje dat. (Pokud například zdroj dat automaticky vytvoří jedinečné hodnoty primárního klíče, je možné tyto hodnoty rozšířit zpět do klientské aplikace.) V obou případech je možné vrácenou DataTable metodou sloučit zpět do původní DataTableMerge klientské aplikace.

Při slučování nového zdroje DataTable do cíle se všechny zdrojové řádky s DataRowState hodnotou Unchanged, Modifiednebo Deleted shodují s cílovými řádky se stejnými hodnotami primárního klíče. Zdrojové řádky s DataRowState hodnotou jsou Added spárovány s novými cílovými řádky se stejnými hodnotami primárního klíče jako nové zdrojové řádky.

Viz také

• Datové tabulky
• Zpracování událostí datové tabulky

Zdroj:

DataTable.cs

Zdroj:

DataTable.cs

Zdroj:

DataTable.cs

public:
 void Merge(System::Data::DataTable ^ table);

public void Merge (System.Data.DataTable table);

member this.Merge : System.Data.DataTable -> unit

Public Sub Merge (table As DataTable)

Parametry

Příklady

Následující konzolová aplikace vytvoří jednoduchou DataTable aplikaci a přidá do tabulky data. Příklad pak vytvoří kopii tabulky a přidá do kopie řádky. Nakonec příklad volá metodu Merge pro sloučení dat v druhé tabulce s daty v první tabulce.

private static void DemonstrateMergeTable()
{
    DataTable table1 = new DataTable("Items");

    // Add columns
    DataColumn column1 = new DataColumn("id", typeof(System.Int32));
    DataColumn column2 = new DataColumn("item", typeof(System.Int32));
    table1.Columns.Add(column1);
    table1.Columns.Add(column2);

    // Set the primary key column.
    table1.PrimaryKey = new DataColumn[] { column1 };

    // Add RowChanged event handler for the table.
    table1.RowChanged +=
        new System.Data.DataRowChangeEventHandler(Row_Changed);

    // Add some rows.
    DataRow row;
    for (int i = 0; i <= 3; i++)
    {
        row = table1.NewRow();
        row["id"] = i;
        row["item"] = i;
        table1.Rows.Add(row);
    }

    // Accept changes.
    table1.AcceptChanges();
    PrintValues(table1, "Original values");

    // Create a second DataTable identical to the first.
    DataTable table2 = table1.Clone();

    // Add three rows. Note that the id column can't be the
    // same as existing rows in the original table.
    row = table2.NewRow();
    row["id"] = 14;
    row["item"] = 774;
    table2.Rows.Add(row);

    row = table2.NewRow();
    row["id"] = 12;
    row["item"] = 555;
    table2.Rows.Add(row);

    row = table2.NewRow();
    row["id"] = 13;
    row["item"] = 665;
    table2.Rows.Add(row);

    // Merge table2 into the table1.
    Console.WriteLine("Merging");
    table1.Merge(table2);
    PrintValues(table1, "Merged With table1");
}

private static void Row_Changed(object sender,
    DataRowChangeEventArgs e)
{
    Console.WriteLine("Row changed {0}\t{1}",
        e.Action, e.Row.ItemArray[0]);
}

private static void PrintValues(DataTable table, string label)
{
    // Display the values in the supplied DataTable:
    Console.WriteLine(label);
    foreach (DataRow row in table.Rows)
    {
        foreach (DataColumn col in table.Columns)
        {
            Console.Write("\t " + row[col].ToString());
        }
        Console.WriteLine();
    }
}

Private Sub DemonstrateMergeTable()
  Dim table1 As New DataTable("Items")

  ' Add columns
  Dim column1 As New DataColumn("id", GetType(System.Int32))
  Dim column2 As New DataColumn("item", GetType(System.Int32))
  table1.Columns.Add(column1)
  table1.Columns.Add(column2)

  ' Set the primary key column.
  table1.PrimaryKey = New DataColumn() {column1}

  ' Add RowChanged event handler for the table.
  AddHandler table1.RowChanged, AddressOf Row_Changed

  ' Add some rows.
  Dim row As DataRow
  For i As Integer = 0 To 3
    row = table1.NewRow()
    row("id") = i
    row("item") = i
    table1.Rows.Add(row)
  Next i

  ' Accept changes.
  table1.AcceptChanges()
  PrintValues(table1, "Original values")

  ' Create a second DataTable identical to the first.
  Dim table2 As DataTable = table1.Clone()

  ' Add three rows. Note that the id column can't be the 
  ' same as existing rows in the original table.
  row = table2.NewRow()
  row("id") = 14
  row("item") = 774
  table2.Rows.Add(row)

  row = table2.NewRow()
  row("id") = 12
  row("item") = 555
  table2.Rows.Add(row)

  row = table2.NewRow()
  row("id") = 13
  row("item") = 665
  table2.Rows.Add(row)

  ' Merge table2 into the table1.
  Console.WriteLine("Merging")
  table1.Merge(table2)
  PrintValues(table1, "Merged With table1")

End Sub

Private Sub Row_Changed(ByVal sender As Object, _
  ByVal e As DataRowChangeEventArgs)
  Console.WriteLine("Row changed {0}{1}{2}", _
    e.Action, ControlChars.Tab, e.Row.ItemArray(0))
End Sub

Private Sub PrintValues(ByVal table As DataTable, _
  ByVal label As String)
  ' Display the values in the supplied DataTable:
  Console.WriteLine(label)
  For Each row As DataRow In table.Rows
    For Each col As DataColumn In table.Columns
      Console.Write(ControlChars.Tab + " " + row(col).ToString())
    Next col
    Console.WriteLine()
  Next row
End Sub

Poznámky

Metoda Merge se používá ke sloučení dvou DataTable objektů, které mají do značné míry podobná schémata. Sloučení se obvykle používá v klientské aplikaci k začlenění nejnovějších změn ze zdroje dat do existujícího DataTable. To umožňuje klientské aplikaci aktualizovat DataTable nejnovějšími daty ze zdroje dat.

Operace sloučení bere v úvahu pouze původní tabulku a tabulku, která se má sloučit. Podřízené tabulky nejsou ovlivněny ani zahrnuty. Pokud má tabulka jednu nebo více podřízených tabulek definovaných jako součást relace, musí být každá podřízená tabulka sloučena samostatně.

Metoda se Merge obvykle volá na konci řady procedur, které zahrnují ověření změn, odsouhlasení chyb, aktualizaci zdroje dat pomocí změn a nakonec aktualizaci existujícího DataTableobjektu .

Při provádění sloučení se změny provedené v existujících datech před sloučením během operace sloučení ve výchozím nastavení zachovají. Vývojáři mohou toto chování upravit voláním jednoho ze dvou dalších přetížení pro tuto metodu a zadáním false hodnoty parametru preserveChanges .

V klientské aplikaci je obvyklé, že uživatel může kliknout na jediné tlačítko, které shromáždí změněná data a ověří je před odesláním zpět do komponenty střední vrstvy. V tomto scénáři GetChanges je nejprve vyvolána metoda. Tato metoda vrátí sekundu DataTable optimalizovanou pro ověřování a slučování. Tento druhý DataTable objekt obsahuje pouze DataRow objekty, které byly změněny, což vede k podmnožině původního DataTableobjektu . Tato podmnožina je obecně menší, a proto se efektivněji předává zpět do komponenty střední vrstvy. Komponenta střední vrstvy pak aktualizuje původní zdroj dat o změny prostřednictvím uložených procedur. Střední vrstva pak může odeslat zpět buď novou DataTable , která obsahuje původní data a nejnovější data ze zdroje dat (opětovným spuštěním původního dotazu), nebo může odeslat zpět podmnožinu se všemi změnami, které byly provedeny ze zdroje dat. (Pokud například zdroj dat automaticky vytvoří jedinečné hodnoty primárního klíče, je možné tyto hodnoty rozšířit zpět do klientské aplikace.) V obou případech je možné vrácenou DataTable metodou sloučit zpět do původní DataTableMerge klientské aplikace.

Při slučování nového zdroje DataTable do cíle se všechny zdrojové řádky s hodnotou Unchanged, Modifiednebo Deletedshodují s DataRowState cílovými řádky se stejnými hodnotami primárního klíče. Zdrojové řádky s DataRowState hodnotou Added jsou spárovány s novými cílovými řádky se stejnými hodnotami primárního klíče jako nové zdrojové řádky.

Viz také

• Datové tabulky
• Zpracování událostí datové tabulky