Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source

DataSet.Merge, méthode (DataSet, Boolean, MissingSchemaAction)

Fusionne un DataSet spécifié et son schéma avec le DataSet en cours, en préservant ou en supprimant les modifications apportées au DataSet en cours, et en traitant un schéma incompatible conformément aux arguments donnés.

Espace de noms :  System.Data
Assembly :  System.Data (dans System.Data.dll)

public void Merge(
	DataSet dataSet,
	bool preserveChanges,
	MissingSchemaAction missingSchemaAction
)

Paramètres

dataSet
Type : System.Data.DataSet
DataSet dont les données et le schéma doivent être fusionnés.
preserveChanges
Type : System.Boolean
true pour préserver les modifications apportées au DataSet en cours ; sinon, false.
missingSchemaAction
Type : System.Data.MissingSchemaAction
Une des valeurs de MissingSchemaAction.

ExceptionCondition
ArgumentNullException

Le dataSet est null.

La méthode Merge est utilisée pour fusionner deux objets DataSet qui possèdent des schémas extrêmement 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 DataSet existant. Cela permet à l'application cliente de disposer d'un DataSet actualisé avec les dernières données provenant de la source de données.

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 DataSet existant.

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 DataSet optimisé pour la validation et la fusion. Ce deuxième objet DataSet contient uniquement les objets DataTable et DataRow qui ont été modifiés, générant ainsi un sous-ensemble du DataSet d'origine. Ce sous-ensemble est généralement plus petit et 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 DataSet 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 DataSet retourné peut être refusionné dans le DataSet d'origine de l'application cliente à l'aide de la méthode Merge.

Pour faciliter l'explication de la méthode Merge, nous utilisons le terme « cible » pour désigner le DataSet en cours et le terme « source » pour le deuxième (paramètre) DataSet. Le DataSet cible porte ce nom, car il s'agit de l'objet sur lequel une action (la fusion) est exécutée. Le deuxième DataSet est appelé « source », car les informations qu'il contient ne sont pas modifiées, mais bien fusionnées dans le DataSet en cours.

Lorsque la méthode Merge est appelée, les schémas des deux objets DataSet sont comparés, car il est possible qu'ils aient été modifiés. Par exemple, dans un scénario impliquant des entreprises, de nouvelles colonnes peuvent être ajoutées à un schéma XML par un processus automatisé. Si le DataSet source contient des éléments de schéma (objets DataColumn ajoutés) absents de la cible, vous pouvez les ajouter en affectant MissingSchemaAction.Add comme valeur de l'argument missingSchemaAction. Dans ce cas, le DataSet fusionné contient le schéma et les données ajoutés.

La fusion des données suit celle des schémas.

Lors de la fusion d'un nouveau DataSet 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.

Pendant une fusion, les contraintes sont désactivées. Si des contraintes ne peuvent pas être activées à la fin d'une fusion, l'exception ConstraintException est levée et les données fusionnées sont conservées alors que les contraintes sont désactivées. Dans ce cas, la valeur false est affectée à la propriété EnforceConstraints et toutes les lignes non valides sont marquées comme erronées. Les erreurs doivent être résolues avant de tenter de rétablir true comme valeur de EnforceConstraints.

L'exemple suivant crée un DataSet simple avec une table, deux colonnes et dix lignes. Deux valeurs sont modifiées et une ligne est ajoutée. Un sous-ensemble des données modifiées est créé à l'aide de la méthode GetChanges. Une fois les erreurs harmonisées, une nouvelle colonne est ajoutée au sous-ensemble, modifiant ainsi le schéma. Si la méthode Merge est appelée avec la valeur du paramètre missingSchemaAction égale à MissingSchemaAction.Add, la nouvelle colonne est ajoutée au schéma de l'objet DataSet d'origine.


private void DemonstrateMergeMissingSchema()
{
    // Create a DataSet with one table, two columns, 
    // and three rows.
    DataSet dataSet = new DataSet("dataSet");
    DataTable table = new DataTable("Items");
    DataColumn idColumn = new DataColumn("id", 
        Type.GetType("System.Int32"));
    idColumn.AutoIncrement=true;
    DataColumn itemColumn = new DataColumn("Item", 
        Type.GetType("System.Int32"));
    // DataColumn array to set primary key.

    DataColumn[] keyColumn= new DataColumn[1];
    DataRow row;
    // Create variable for temporary DataSet. 
    DataSet changeDataSet;

    // Add RowChanged event handler for the table.
    table.RowChanged+= new DataRowChangeEventHandler(
        Row_Changed);
    dataSet.Tables.Add(table);
    table.Columns.Add(idColumn);
    table.Columns.Add(itemColumn);

    // Set primary key column.
    keyColumn[0]= idColumn;
    table.PrimaryKey=keyColumn;

    // Add ten rows.
    for(int i = 0; i <10;i++)
    {
        row=table.NewRow();
        row["Item"]= i;
        table.Rows.Add(row);
    }

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

    // Change row values.
    table.Rows[0]["Item"]= 50;
    table.Rows[1]["Item"]= 111;

    // Add one row.
    row=table.NewRow();
    row["Item"]=74;
    table.Rows.Add(row);

    // Insert code for error checking. Set one row in error.
    table.Rows[1].RowError= "over 100";
    PrintValues(dataSet, "Modified and New Values");
    // If the table has changes or errors, create a subset DataSet.
    if(dataSet.HasChanges(DataRowState.Modified | 
        DataRowState.Added)& dataSet.HasErrors)
    {
        // Use GetChanges to extract subset.
        changeDataSet = dataSet.GetChanges(
            DataRowState.Modified|DataRowState.Added);
        PrintValues(changeDataSet, "Subset values");

        // Insert code to reconcile errors. Reject the changes.
        foreach(DataTable changeTable in changeDataSet.Tables)
        {
            if (changeTable.HasErrors)
            {
                foreach(DataRow changeRow in changeTable.Rows)
                {
                    //Console.WriteLine(changeRow["Item"]);
                    if((int)changeRow["Item", 
                        DataRowVersion.Current ]> 100)
                    {
                        changeRow.RejectChanges();
                        changeRow.ClearErrors();
                    }
                }
            }
        }
        // Add a column to the changeDataSet to change the schema.
        changeDataSet.Tables["Items"].Columns.Add(
            new DataColumn("newColumn"));
        PrintValues(changeDataSet, "Reconciled subset values");

        // Add values to the rows for each column.
        foreach(DataRow rowItem in changeDataSet.Tables["Items"].Rows)
        {
            rowItem["newColumn"] = "my new schema value";
        }
        // Merge changes back to first DataSet.
        dataSet.Merge(changeDataSet, false,
            System.Data.MissingSchemaAction.Add);
    }
    PrintValues(dataSet, "Merged Values");
}

private void Row_Changed(object sender, DataRowChangeEventArgs e)
{
    Console.WriteLine("Row Changed " + e.Action.ToString() 
        + "\table" + e.Row.ItemArray[0]);
}

private void PrintValues(DataSet dataSet, string label)
{
    Console.WriteLine("\n" + label);
    foreach(DataTable table in dataSet.Tables)
    {
        Console.WriteLine("TableName: " + table.TableName);
        foreach(DataRow row in table.Rows)
        {
            foreach(DataColumn column in table.Columns)
            {
                Console.Write("\table " + row[column] );
            }
            Console.WriteLine();
        }
    }
}


.NET Framework

Pris en charge dans : 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, 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)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft