Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo DataSet.Merge (DataSet, Boolean)

 

Data di pubblicazione: ottobre 2016

Unisce un oggetto DataSet e il relativo schema nell'oggetto corrente DataSet, mantenendo o ignorando eventuali modifiche apportate in questa DataSet in base all'argomento specificato.

Spazio dei nomi:   System.Data
Assembly:  System.Data (in System.Data.dll)

public void Merge(
	DataSet dataSet,
	bool preserveChanges
)

Parametri

dataSet
Type: System.Data.DataSet

Il DataSet verranno uniti i cui dati e schema.

preserveChanges
Type: System.Boolean

true Per mantenere le modifiche nell'oggetto DataSet; in caso contrario false.

Il Merge metodo viene utilizzato per unire due DataSet gli oggetti che contengono schemi molto simili. Un'unione viene in genere utilizzata in un'applicazione client per incorporare le modifiche più recenti da un'origine dati in un oggetto esistente DataSet. In questo modo l'applicazione client per un aggiornamento DataSet con i dati più recenti dall'origine dati.

Il Merge viene in genere chiamato alla fine di una serie di procedure che comportano la convalida delle modifiche, la risoluzione degli errori, aggiornare l'origine dati con le modifiche e infine l'aggiornamento esistente DataSet.

In un'applicazione client, è normale che un singolo pulsante che l'utente può scegliere di raccoglie i dati modificati e convalidarli prima di inviarlo a un componente di livello intermedio. In questo scenario, il GetChanges viene prima richiamato metodo. Questo metodo restituisce un secondo DataSet ottimizzato per la convalida e l'unione. Questo secondo DataSet oggetto contiene solo il DataTable e DataRow gli oggetti che sono stati modificati, causando un sottoinsieme dell'originale DataSet. Questo subset è in genere dimensioni inferiore e pertanto più efficiente passare a un componente di livello intermedio. Il componente di livello intermedio quindi aggiorna l'origine dei dati con le modifiche tramite stored procedure. Il livello intermedio può quindi inviare nuovamente un nuovo DataSet che include i dati originali e i dati più recenti dall'origine dati (se eseguire nuovamente la query originale) o restituire il sottoinsieme con eventuali modifiche apportate all'origine dati. (Ad esempio, se l'origine dati crea automaticamente i valori di chiave primari univoca, questi valori possono essere propagati all'applicazione client.) In entrambi i casi, l'oggetto restituito DataSet possono essere reinseriti nell'originale dell'applicazione client DataSet con il Merge metodo.

Quando il Merge metodo viene chiamato, gli schemi dei due DataSet gli oggetti vengono confrontati perché è possibile che gli schemi potrebbero essere stati modificati. Ad esempio, in uno scenario business-to-business, nuove colonne possono aggiunti a uno schema XML da un processo automatizzato. Se l'origine DataSet contiene gli elementi dello schema (aggiunto DataColumn oggetti) che non sono presenti nel database di destinazione, è possono aggiungere gli elementi dello schema di destinazione impostando il missingSchemaAction argomento MissingSchemaAction.Add. In tal caso, l'oggetto unito DataSet contiene i dati e lo schema aggiunto.

Dopo l'unione di schemi, i dati vengono uniti.

Quando si uniscono una nuova origine DataSet nella destinazione, qualsiasi origine le righe con un DataRowState valore Unchanged, Modified, o Deleted corrispondono alle righe di destinazione con gli stessi valori di chiave primari. Origine le righe con un DataRowState valore Added corrispondono alle nuove righe di destinazione con gli stessi valori di chiave primari delle nuove righe di origine.

Durante un'unione, i vincoli sono disabilitati. Se tutti i vincoli non sono abilitati alla fine dell'unione, un ConstraintException viene generato e i dati uniti verranno mantenuti, mentre i vincoli sono disabilitati. In questo caso, il EnforceConstraints è impostata su false, e tutte le righe che non sono valide sono segnalate come errori. È necessario risolvere gli errori prima di tentare di reimpostare il EnforceConstraints proprietà true.

Nell'esempio seguente viene creato un semplice DataSet con una tabella, due colonne e dieci righe. Una volta aggiunte dieci righe, due valori vengono modificati, e viene aggiunta una riga. Viene creato un sottoinsieme dei dati modificati mediante la GetChanges metodo. Dopo la risoluzione degli errori, i dati del sottoinsieme viene uniti all'originale DataSet.

private void DemonstrateMerge()
{
    // 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 changesDataSet;

    // 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.
        changesDataSet = dataSet.GetChanges(
            DataRowState.Modified|DataRowState.Added);
        PrintValues(changesDataSet, "Subset values");

        // Insert code to reconcile errors. In this case, reject changes.
        foreach(DataTable changesTable in changesDataSet.Tables)
        {
            if (changesTable.HasErrors)
            {
                foreach(DataRow changesRow in changesTable.Rows)
                {
                    //Console.WriteLine(changesRow["Item"]);
                    if((int)changesRow["Item",DataRowVersion.Current ]> 100)
                    {
                        changesRow.RejectChanges();
                        changesRow.ClearErrors();
                    }
                }
            }
        }
        // Add a column to the changesDataSet.
        changesDataSet.Tables["Items"].Columns.Add(
            new DataColumn("newColumn"));
        PrintValues(changesDataSet, "Reconciled subset values");
        // Merge changes back to first DataSet.
        dataSet.Merge(changesDataSet, 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(label + "\n");
    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
Disponibile da 1.1
Torna all'inizio
Mostra: