Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

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

 

Date de publication : novembre 2016

Fusionne un DataSet et son schéma avec actuel DataSet, en préservant ou en supprimant les modifications en cours DataSet et 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

Les DataSet dont les données et schéma seront fusionnés.

preserveChanges
Type: System.Boolean

true Pour conserver les modifications en cours DataSet; sinon false.

missingSchemaAction
Type: System.Data.MissingSchemaAction

Une des valeurs de MissingSchemaAction.

Exception Condition
ArgumentNullException

dataSet a la valeur null.

Le Merge méthode est utilisée pour fusionner deux DataSet objets qui possèdent des schémas extrêmement similaires. Une fusion est généralement utilisée dans une application cliente pour incorporer les dernières modifications à partir d’une source de données dans une DataSet. Cela permet à l’application cliente pour avoir une actualisation DataSet avec les dernières données de la source de données.

Le Merge méthode est généralement appelée à la fin d’une série de procédures qui impliquent la validation des modifications, harmonisation des erreurs, mise à jour de la source de données avec les modifications et enfin l’actualisation existant DataSet.

Dans une application cliente, il est courant d’avoir un seul bouton que l’utilisateur peut cliquer qui rassemble les données modifiées et le valide avant de l’envoyer à un composant de couche intermédiaire. Dans ce scénario, le GetChanges méthode est appelée en premier. Cette méthode retourne un deuxième DataSet optimisé pour la validation et la fusion. Cette seconde DataSet objet contient uniquement les DataTable et DataRow les objets qui ont été modifiés, générant ainsi un sous-ensemble de l’original DataSet. Ce sous-ensemble est généralement plus petit, et 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 apportées par le biais des procédures stockées. La couche intermédiaire renvoie alors un nouveau DataSet qui inclut des données d’origine et les données les plus récentes à partir de la source de données (en exécutant à nouveau la requête d’origine), ou il peut envoyer le sous-ensemble avec toutes les modifications ont été apportées à partir de la source de données. (Par exemple, si la source de données crée automatiquement des valeurs de clé primaire uniques, ces valeurs peuvent être propagées à l’application cliente.) Dans les deux cas, le code DataSet peuvent être fusionnées dans d’origine de l’application cliente DataSet avec la Merge méthode.

Pour faciliter l’explication de la Merge méthode, nous utilisons « cible » pour signifier actuel DataSet, et « source » pour le deuxième (paramètre) DataSet. La cible DataSet est ainsi nommé car il s’agit de l’objet sur lequel une action (la fusion) se produit. La seconde DataSet est appelé « source », car les informations qu’il contient ne changent pas, mais fusionnées dans actuel DataSet.

Lors de la Merge méthode est appelée, les schémas des deux DataSet objets sont comparés, car il est possible que peut avoir été modifié. Par exemple, dans un scénario d’entreprise-entreprise, nouvelles colonnes peuvent ont été ajoutées à un schéma XML par un processus automatisé. Si la source de DataSet contient les éléments de schéma (ajouté DataColumn objets) qui n’apparaissent pas dans la cible, les éléments de schéma peuvent être ajoutés à la cible en définissant le missingSchemaAction argument MissingSchemaAction.Add. Dans ce cas, la fusion DataSet contient des données et le schéma ajouté.

Après la fusion des schémas, les données sont fusionnées.

Lors de la fusion d’une nouvelle source de DataSet dans la cible, toutes les lignes sources avec un DataRowState valeur Unchanged, Modified, ou Deleted sont mis en correspondance avec les lignes cibles ayant les mêmes valeurs de clé primaire. Source de lignes avec un DataRowState valeur Added sont mis en correspondance avec les nouvelles lignes cibles possédant les mêmes valeurs de clés primaires que les nouvelles lignes de la source.

Pendant une fusion, les contraintes sont désactivées. Si des contraintes ne peuvent pas être activées à la fin de la fusion, un ConstraintException est généré et les données fusionnées sont conservées alors que les contraintes sont désactivées. Dans ce cas, le EnforceConstraints est définie sur false, et toutes les lignes qui ne sont pas valides dans l’erreur. Les erreurs doivent être résolues avant de tenter de réinitialiser le EnforceConstraints propriété true.

L’exemple suivant crée un simple DataSet 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 GetChanges méthode. Après l’harmonisation des erreurs, une nouvelle colonne est ajoutée au sous-ensemble, modification du schéma. Lors de la Merge méthode est appelée avec le missingSchemaAction défini sur MissingSchemaAction.Add, la nouvelle colonne est ajoutée à l’original DataSet schéma de l’objet.

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
Disponible depuis 1.1
Retour au début
Afficher: