DataTable.Merge Metod

Definition

Namnområde:
System.Data
Sammansättningar:
netstandard.dll, System.Data.Common.dll
Sammansättning:
System.Data.Common.dll
Sammansättning:
System.Data.dll
Sammansättning:
netstandard.dll

Sammanfoga den angivna DataTable med den aktuella DataTable.

Överlagringar

Name Description
Merge(DataTable, Boolean, MissingSchemaAction)

Sammanfoga den angivna DataTable med den aktuella DataTable, som anger om ändringar ska bevaras och hur du hanterar det saknade schemat i den aktuella DataTable.
Merge(DataTable, Boolean)

Sammanfoga den angivna DataTable med den aktuella DataTable, som anger om ändringar ska bevaras i den aktuella DataTable.
Merge(DataTable)

Sammanfoga den angivna DataTable med den aktuella DataTable.

Exempel

Följande konsolprogram visar beteendet för parametern missingSchemaAction för Merge metoden. Det här exemplet skapar två versioner av samma tabell och ändrar schemat för den andra versionen. Koden försöker sedan sammanfoga den andra tabellen till den första.

Note

Det här exemplet visar hur du använder en av de överlagrade versionerna av Merge. Andra exempel som kan vara tillgängliga finns i de enskilda överlagringsämnena.

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

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

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

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

    // Add ten rows.
    DataRow row;
    for (int i = 0; i <= 9; 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 column to the second column, so that the
    // schemas no longer match.
    table2.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 = table2.NewRow();
    row["id"] = 14;
    row["item"] = 774;
    row["newColumn"] = "new column 1";
    table2.Rows.Add(row);

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

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

    // Merge table2 into the table1.
    Console.WriteLine("Merging");
    table1.Merge(table2, false, MissingSchemaAction.Add);
    PrintValues(table1, "Merged With table1, 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 table1 As New DataTable("Items")

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

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

  ' 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 column to the second column, so that the 
  ' schemas no longer match.
  table2.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 = table2.NewRow()
  row("id") = 14
  row("item") = 774
  row("newColumn") = "new column 1"
  table2.Rows.Add(row)

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

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

  ' Merge table2 into the table1.
  Console.WriteLine("Merging")
  table1.Merge(table2, False, MissingSchemaAction.Add)
  PrintValues(table1, "Merged With table1, 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

Kommentarer

Metoden Merge används för att sammanfoga två DataTable objekt som i stort sett har liknande scheman. En sammanslagning används vanligtvis i ett klientprogram för att införliva de senaste ändringarna från en datakälla i en befintlig DataTable. Detta gör att klientprogrammet kan uppdateras DataTable med de senaste data från datakällan.

Sammanslagningsåtgärden tar endast hänsyn till den ursprungliga tabellen och den tabell som ska sammanfogas. Underordnade tabeller påverkas inte eller inkluderas. Om en tabell har en eller flera underordnade tabeller, definierade som en del av en relation, måste varje underordnad tabell sammanfogas individuellt.

Merge(DataTable, Boolean, MissingSchemaAction)

Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs

Sammanfoga den angivna DataTable med den aktuella DataTable, som anger om ändringar ska bevaras och hur du hanterar det saknade schemat i den aktuella DataTable.

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)

Parametrar

table
DataTable

Som DataTable ska sammanfogas med den aktuella DataTable.

preserveChanges
Boolean

true, för att bevara ändringar i den aktuella DataTable, annars false.

missingSchemaAction
MissingSchemaAction

Ett av MissingSchemaAction värdena.

Exempel

Följande konsolprogram visar beteendet för parametern missingSchemaAction för Merge metoden. Det här exemplet skapar två versioner av samma tabell och ändrar schemat för den andra versionen. Koden försöker sedan sammanfoga den andra tabellen till den första.

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

Kommentarer

Metoden Merge används för att sammanfoga två DataTable objekt som i stort sett har liknande scheman. En sammanslagning används vanligtvis i ett klientprogram för att införliva de senaste ändringarna från en datakälla i en befintlig DataTable. Detta gör att klientprogrammet kan uppdateras DataTable med de senaste data från datakällan.

Sammanslagningsåtgärden tar endast hänsyn till den ursprungliga tabellen och den tabell som ska sammanfogas. Underordnade tabeller påverkas inte eller inkluderas. Om en tabell har en eller flera underordnade tabeller, definierade som en del av en relation, måste varje underordnad tabell sammanfogas individuellt.

Metoden Merge anropas vanligtvis i slutet av en serie procedurer som omfattar validering av ändringar, avstämning av fel, uppdatering av datakällan med ändringarna och slutligen uppdatering av den befintliga DataTable.

När du utför en sammanslagning bevaras ändringar som gjorts i befintliga data innan sammanfogningen under sammanslagningsåtgärden, såvida inte utvecklaren anger falskt för parametern preserveChanges . Om parametern preserveChanges är inställd truepå skriver inkommande värden inte över befintliga värden i den aktuella radversionen av den befintliga raden. Om parametern preserveChanges är inställd på falseskriver inkommande värden över de befintliga värdena i den aktuella radversionen av den befintliga raden. Mer information om radversioner finns i Radtillstånd och Radversioner.

I ett klientprogram är det vanligt att ha en enda knapp som användaren kan klicka på som samlar in ändrade data och validerar dem innan den skickas tillbaka till en mellannivåkomponent. I det här scenariot GetChanges anropas metoden först. Den metoden returnerar en andra DataTable optimerad för validering och sammanslagning. Det andra DataTable objektet innehåller endast objekten DataTable och DataRow som har ändrats, vilket resulterar i en delmängd av den ursprungliga DataTable. Den här delmängden är vanligtvis mindre och därför skickas den här delmängden mer effektivt tillbaka till en komponent på mellannivå. Komponenten på mellannivån uppdaterar sedan den ursprungliga datakällan med ändringarna genom lagrade procedurer. Mellannivån kan sedan skicka tillbaka antingen en ny DataTable som innehåller ursprungliga data och de senaste data från datakällan (genom att köra den ursprungliga frågan igen), eller så kan den skicka tillbaka delmängden med eventuella ändringar som har gjorts i den från datakällan. (Om datakällan till exempel automatiskt skapar unika primärnyckelvärden kan dessa värden spridas tillbaka till klientprogrammet.) I båda fallen kan den returnerade DataTable slås tillbaka till klientprogrammets ursprungliga DataTable med Merge -metoden.

Merge När metoden anropas jämförs scheman för de två DataTable objekten, eftersom det är möjligt att schemana kan ha ändrats. I ett affärs-till-företag-scenario kan till exempel nya kolumner ha lagts till i ett XML-schema av en automatiserad process. Om källan DataTable innehåller schemaelement (tillagda DataColumn objekt) som saknas i målet kan schemaelementen läggas till i målet genom att argumentet anges missingSchemaAction till MissingSchemaAction.Add. I så fall innehåller den sammanslagna DataTable filen det tillagda schemat och data.

Efter sammanslagning av scheman sammanfogas data.

När du sammanfogar en ny källa DataTable till målet matchas alla källrader med DataRowState värdet Unchanged, Modifiedeller Deleted med målrader med samma primärnyckelvärden. Källrader med värdet DataRowState för Added matchas mot nya målrader med samma primärnyckelvärden som de nya källraderna.

Se även

Gäller för

Merge(DataTable, Boolean)

Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs

Sammanfoga den angivna DataTable med den aktuella DataTable, som anger om ändringar ska bevaras i den aktuella DataTable.

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)

Parametrar

table
DataTable

Som DataTable ska sammanfogas med den aktuella DataTable.

preserveChanges
Boolean

true, för att bevara ändringar i den aktuella DataTable, annars false.

Exempel

Följande konsolprogram skapar en DataTable innehållande rader, ändrar en del av data i dessa rader och försöker sammanfoga data från en annan DataTable. Exemplet visar de olika beteendena för parametern 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

Kommentarer

Metoden Merge används för att sammanfoga två DataTable objekt som i stort sett har liknande scheman. En sammanslagning används vanligtvis i ett klientprogram för att införliva de senaste ändringarna från en datakälla i en befintlig DataTable. Detta gör att klientprogrammet kan uppdateras DataTable med de senaste data från datakällan.

Sammanslagningsåtgärden tar endast hänsyn till den ursprungliga tabellen och den tabell som ska sammanfogas. Underordnade tabeller påverkas inte eller inkluderas. Om en tabell har en eller flera underordnade tabeller, definierade som en del av en relation, måste varje underordnad tabell sammanfogas individuellt.

Metoden Merge anropas vanligtvis i slutet av en serie procedurer som omfattar validering av ändringar, avstämning av fel, uppdatering av datakällan med ändringarna och slutligen uppdatering av den befintliga DataTable.

När du utför en sammanslagning bevaras ändringar som gjorts i befintliga data innan sammanfogningen under sammanslagningsåtgärden, såvida inte utvecklaren anger falskt för parametern preserveChanges . Om parametern preserveChanges är inställd truepå skriver inkommande värden inte över befintliga värden i den aktuella radversionen av den befintliga raden. Om parametern preserveChanges är inställd på falseskriver inkommande värden över de befintliga värdena i den aktuella radversionen av den befintliga raden. Mer information om radversioner finns i Radtillstånd och Radversioner.

I ett klientprogram är det vanligt att ha en enda knapp som användaren kan klicka på som samlar in ändrade data och validerar dem innan den skickas tillbaka till en mellannivåkomponent. I det här scenariot GetChanges anropas metoden först. Den metoden returnerar en andra DataTable optimerad för validering och sammanslagning. Det andra DataTable objektet innehåller endast objekten DataTable och DataRow som har ändrats, vilket resulterar i en delmängd av den ursprungliga DataTable. Den här delmängden är vanligtvis mindre och därför skickas den här delmängden mer effektivt tillbaka till en komponent på mellannivå. Komponenten på mellannivån uppdaterar sedan den ursprungliga datakällan med ändringarna genom lagrade procedurer. Mellannivån kan sedan skicka tillbaka antingen en ny DataTable som innehåller ursprungliga data och de senaste data från datakällan (genom att köra den ursprungliga frågan igen), eller så kan den skicka tillbaka delmängden med eventuella ändringar som har gjorts i den från datakällan. (Om datakällan till exempel automatiskt skapar unika primärnyckelvärden kan dessa värden spridas tillbaka till klientprogrammet.) I båda fallen kan den returnerade DataTable slås tillbaka till klientprogrammets ursprungliga DataTable med Merge -metoden.

När du sammanfogar en ny källa DataTable till målet matchas alla källrader med DataRowState värdet Unchanged, Modifiedeller Deleted med målrader med samma primärnyckelvärden. Källrader med värdet DataRowState för Added matchas mot nya målrader med samma primärnyckelvärden som de nya källraderna.

Se även

Gäller för

Merge(DataTable)

Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs
Källa:
DataTable.cs

Sammanfoga den angivna DataTable med den aktuella DataTable.

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)

Parametrar

table
DataTable

Som DataTable ska sammanfogas med den aktuella DataTable.

Exempel

Följande konsolprogram skapar en enkel DataTable och lägger till data i tabellen. Exemplet skapar sedan en kopia av tabellen och lägger till rader i kopian. Slutligen anropar Merge exemplet metoden för att sammanfoga data i den andra tabellen med data i den första tabellen.

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

Kommentarer

Metoden Merge används för att sammanfoga två DataTable objekt som i stort sett har liknande scheman. En sammanslagning används vanligtvis i ett klientprogram för att införliva de senaste ändringarna från en datakälla i en befintlig DataTable. Detta gör att klientprogrammet kan uppdateras DataTable med de senaste data från datakällan.

Sammanslagningsåtgärden tar endast hänsyn till den ursprungliga tabellen och den tabell som ska sammanfogas. Underordnade tabeller påverkas inte eller inkluderas. Om en tabell har en eller flera underordnade tabeller, definierade som en del av en relation, måste varje underordnad tabell sammanfogas individuellt.

Metoden Merge anropas vanligtvis i slutet av en serie procedurer som omfattar validering av ändringar, avstämning av fel, uppdatering av datakällan med ändringarna och slutligen uppdatering av den befintliga DataTable.

När du utför en sammanslagning bevaras ändringar som gjorts i befintliga data innan sammanfogningen som standard under sammanslagningsåtgärden. Utvecklare kan ändra det här beteendet genom att anropa en av de andra två överlagringarna för den här metoden och ange ett falskt värde för parametern preserveChanges .

I ett klientprogram är det vanligt att ha en enda knapp som användaren kan klicka på som samlar in ändrade data och validerar dem innan den skickas tillbaka till en mellannivåkomponent. I det här scenariot GetChanges anropas metoden först. Den metoden returnerar en andra DataTable optimerad för validering och sammanslagning. Det andra DataTable objektet innehåller bara de DataRow objekt som har ändrats, vilket resulterar i en delmängd av den ursprungliga DataTable. Den här delmängden är vanligtvis mindre och skickas därför mer effektivt tillbaka till en mellannivåkomponent. Komponenten på mellannivån uppdaterar sedan den ursprungliga datakällan med ändringarna genom lagrade procedurer. Mellannivån kan sedan skicka tillbaka antingen en ny DataTable som innehåller ursprungliga data och de senaste data från datakällan (genom att köra den ursprungliga frågan igen), eller så kan den skicka tillbaka delmängden med eventuella ändringar som har gjorts i den från datakällan. (Om datakällan till exempel automatiskt skapar unika primärnyckelvärden kan dessa värden spridas tillbaka till klientprogrammet.) I båda fallen kan den returnerade DataTable slås tillbaka till klientprogrammets ursprungliga DataTable med Merge -metoden.

När du slår samman en ny källa DataTable till målet matchas alla källrader med DataRowState värdet Unchanged, Modifiedeller Deleted, till målrader med samma primärnyckelvärden. Källrader med värdet DataRowState för Added matchas mot nya målrader med samma primärnyckelvärden som de nya källraderna.

Se även

Gäller för