DataTable.Merge, méthode (DataTable)

La méthode Merge est utilisée pour fusionner deux objets DataTable qui possèdent des schémas très similaires. Une fusion est généralement utilisée sur une application cliente pour incorporer les dernières modifications provenant d'une source de données dans un DataTable existant. Cela permet à l'application cliente de disposer d'un DataTable actualisé avec les dernières données provenant de la source de données.

L'opération de fusion prend uniquement en compte la table d'origine et la table à fusionner. Les tables enfants ne sont ni affectées, ni incluses. Si une table a une ou plusieurs tables enfants au sein d'une relation, chaque table enfant doit être fusionnée individuellement.

La méthode Merge est généralement appelée à la fin d'une série de procédures comprenant la validation des modifications, l'harmonisation des erreurs, la mise à jour de la source de données avec les modifications et enfin l'actualisation du DataTable existant.

Lors de l'exécution d'une fusion, les modifications apportées aux données existantes avant la fusion sont conservées par défaut pendant l'opération de fusion. Les développeurs peuvent modifier ce comportement en appelant l'une des deux autres surcharges pour cette méthode et en spécifiant la valeur false pour le paramètre preserveChanges.

Dans une application cliente, il est courant que l'utilisateur dispose d'un bouton unique sur lequel il peut cliquer pour collecter les données modifiées et les valider avant de les renvoyer à un composant de couche intermédiaire. Dans ce scénario, la méthode GetChanges est appelée en premier. Cette méthode retourne un deuxième DataTable optimisé pour la validation et la fusion. Ce deuxième objet DataTable contient uniquement les objets DataRow qui ont été modifiés, générant ainsi un sous-ensemble du DataTable d'origine. Ce sous-ensemble est généralement plus petit et il peut donc être passé plus efficacement à un composant de couche intermédiaire. Le composant de couche intermédiaire met ensuite à jour la source de données d'origine avec les modifications à l'aide de procédures stockées. La couche intermédiaire renvoie alors un nouveau DataTable qui contient les données d'origine et les données les plus récentes de la source de données (en exécutant à nouveau la requête d'origine) ou le sous-ensemble contenant les modifications éventuellement apportées à partir de la source de données. (Par exemple, si la source de données crée automatiquement des valeurs de clés primaires uniques, elles peuvent être propagées jusqu'à l'application cliente.) Dans les deux cas, le DataTable retourné peut être refusionné dans le DataTable d'origine de l'application cliente à l'aide de la méthode Merge.

Lors de la fusion d'un nouveau DataTable source dans la cible, toutes les lignes sources avec une valeur de DataRowState égale à Unchanged, Modified ou Deleted sont mises en correspondance avec les lignes cibles ayant les mêmes valeurs de clés primaires. Les lignes sources dont la valeur de DataRowState est Added sont mises en correspondance avec les nouvelles lignes cibles possédant les mêmes valeurs de clés primaires que les nouvelles lignes sources.

L'application console suivante crée un DataTable simple et ajoute des données à la table. L'exemple crée ensuite une copie de la table, ajoutant des lignes à la copie. Enfin, l'exemple appelle la méthode Merge pour fusionner les données dans la deuxième table avec les données de la première table.

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();
    }
}

.NET Framework

.NET Framework Client Profile

Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Référence

Autres ressources