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 DataTable.Load (IDataReader)

 

Data di pubblicazione: ottobre 2016

Riempie una DataTable con i valori da un'origine dati utilizzando la classe fornita IDataReader. Se il DataTable contiene già righe, i dati in arrivo dall'origine dati viene uniti con le righe esistenti.

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

public void Load(
	IDataReader reader
)

Parametri

reader
Type: System.Data.IDataReader

Un IDataReader che fornisce un set di risultati.

Il Loadmetodo utilizza il primo set di risultati di caricato IDataReader, e dopo il completamento corretto, imposta la posizione del lettore al set di risultati successivo, se presente. Quando la conversione dei dati, il Load metodo Usa le stesse regole di conversione di DbDataAdapter.Fill metodo.

Il Load metodo necessario prendere in considerazione tre problemi specifici durante il caricamento dei dati da un IDataReader istanza: operazioni di eventi, dati e schema. Quando si lavora con lo schema, il Load metodo potrebbe incontrare le condizioni descritte nella tabella seguente. Le operazioni dello schema si verificano per tutti i set di risultati importati, anche quelli che non contengono dati.

Condizione

Comportamento

Il DataTable dispone di alcuno schema.

Il Load metodo deduce lo schema basato sul set di risultati dal importata IDataReader.

Il DataTable dispone di uno schema, ma non è compatibile con lo schema caricato.

Il Load metodo genera un'eccezione corrispondente all'errore specifico che si verifica quando si tenta di caricare i dati in schemi incompatibili.

Gli schemi sono compatibili, ma lo schema di set di risultati caricato contiene colonne che non esistono nel file di DataTable.

Il Load metodo aggiunge le colonne in più DataTabledi schema. Il metodo genera un'eccezione se corrispondenti colonne di DataTable e il set di risultati caricato non sono compatibili valore. Il metodo recupera inoltre informazioni sui vincoli dal set di risultati per tutte le colonne aggiunte. Ad eccezione del caso di un vincolo Primary Key, queste informazioni di vincolo viene utilizzate solo se l'oggetto DataTable non contiene tutte le colonne all'inizio dell'operazione di caricamento.

Gli schemi sono compatibili, ma lo schema di set di risultati caricato contiene un numero di colonne rispetto a quello di DataTable.

Se una colonna mancante dispone di un valore predefinito o il tipo di dati della colonna è nullable, il Load metodo consente di righe da aggiungere, sostituendo il valore predefinito o null valore per la colonna mancante. Se nessun valore predefinito o null può essere utilizzato, il Load metodo genera un'eccezione. Se non è stato fornito alcun valore predefinito, il Load metodo utilizza il null al valore predefinito implicito.

Prima di considerare il comportamento di Load metodo in termini di operazioni sui dati, tenere presente che ogni riga all'interno di un DataTable mantiene sia il valore corrente e il valore originale per ogni colonna. Questi valori possono essere equivalenti, o potrebbe essere diversi se i dati nella riga sono stati modificati dopo il riempimento di DataTable. Per altre informazioni, vedere Stati delle righe e versioni delle righe.

Questa versione di Load metodo tenta di mantenere i valori correnti in ogni riga, lasciando intatto il valore originale. (Se si desidera un maggiore controllo sul comportamento dei dati in ingresso, vedere DataTable.Load.) Se la riga esistente e la riga in arrivo contengono valori di chiave primaria corrispondenti, la riga viene elaborata tramite il valore di stato di riga corrente, in caso contrario viene considerato come una nuova riga.

In termini di operazioni di eventi, il RowChanging evento si verifica prima di ogni riga viene modificato e RowChanged evento si verifica dopo ogni riga è stata modificata. In ogni caso, il Action di proprietà di DataRowChangeEventArgs istanza passata al gestore dell'evento contiene informazioni sulla specifica azione associata all'evento. Valore di questa azione dipende dallo stato della riga prima dell'operazione di caricamento. In ogni caso, entrambi gli eventi si verificano e l'azione è lo stesso per ognuno. L'azione può essere applicato per la versione corrente o originale di ogni riga, o entrambi, a seconda dello stato di riga corrente.

Nella tabella seguente viene visualizzato il comportamento per il Load metodo. La riga finale (denominata "(non presente)") viene descritto il comportamento per le righe in arrivo che non corrisponde ad alcuna riga esistente. Ogni cella in questa tabella viene descritto il valore corrente e originale per un campo all'interno di una riga, insieme al DataRowState per il valore dopo il Load completamento del metodo. In questo caso, il metodo non consente di indicare l'opzione di caricamento e utilizza il valore predefinito PreserveChanges.

DataRowState esistente

I valori dopo Load metodo e azione evento

Aggiunto

Corrente = < Existing >

Originale = < in arrivo >

Stato = < Modifica >

RowAction = ChangeOriginal

Modificato

Corrente = < Existing >

Originale = < in arrivo >

Stato = < Modifica >

RowAction = ChangeOriginal

Eliminato

Corrente = < non disponibile >

Originale = < in arrivo >

Stato = < eliminato >

RowAction = ChangeOriginal

Unchanged

Corrente = < in arrivo >

Originale = < in arrivo >

Stato = < invariato >

RowAction = ChangeCurrentAndOriginal

(Non presente)

Corrente = < in arrivo >

Originale = < in arrivo >

Stato = < invariato >

RowAction = ChangeCurrentAndOriginal

I valori in un DataColumn può essere vincolata tramite l'utilizzo delle proprietà, ad esempio ReadOnly e AutoIncrement. Il Load metodo gestisce tali colonne in modo che sia coerente con il comportamento definito dalle proprietà della colonna. Il vincolo in sola lettura in un DataColumn è applicabile solo per le modifiche apportate in memoria. Il Load metodo sovrascrive i valori della colonna di sola lettura, se necessario.

Per determinare la versione del campo chiave primaria da utilizzare per confrontare la riga corrente con una riga in arrivo, il Load metodo utilizza la versione originale del valore della chiave primaria di una riga, se presente. In caso contrario, il Load metodo utilizza la versione corrente del campo chiave primaria.

L'esempio seguente illustra alcuni dei problemi correlati alla chiamata di Load metodo. In primo luogo, nell'esempio si concentra sui problemi di schema, tra cui l'inferenza di uno schema caricato IDataReader, quindi la gestione di schemi incompatibili e gli schemi con colonne mancanti o aggiuntive. L'esempio chiama quindi il Load (metodo), la visualizzazione dei dati prima e dopo l'operazione di caricamento.

static void Main()
{
    // This example examines a number of scenarios involving the 
    // DataTable.Load method.
    Console.WriteLine("Load a DataTable and infer its schema:");

    // The table has no schema. The Load method will infer the 
    // schema from the IDataReader:
    DataTable table = new DataTable();

    // Retrieve a data reader, based on the Customers data. In
    // an application, this data might be coming from a middle-tier
    // business object:
    DataTableReader reader = new DataTableReader(GetCustomers());

    table.Load(reader);
    PrintColumns(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable from an incompatible IDataReader:");

    // Create a table with a single integer column. Attempt
    // to load data from a reader with a schema that is 
    // incompatible. Note the exception, determined
    // by the particular incompatibility:
    table = GetIntegerTable();
    reader = new DataTableReader(GetStringTable());
    try 
    {
        table.Load(reader);
    } 
    catch (Exception ex) 
    { 
        Console.WriteLine(ex.GetType().Name + ":" + ex.Message);
    }

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable with an IDataReader that has extra columns:");

    // Note that loading a reader with extra columns adds
    // the columns to the existing table, if possible:
    table = GetIntegerTable();
    reader = new DataTableReader(GetCustomers());
    table.Load(reader);
    PrintColumns(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine(
        "Load a DataTable with an IDataReader that has missing columns:");

    // Note that loading a reader with missing columns causes 
    // the columns to be filled with null data, if possible:
    table = GetCustomers();
    reader = new DataTableReader(GetIntegerTable());
    table.Load(reader);
    PrintColumns(table);

    // Demonstrate the various possibilites when loading data 
    // into a DataTable that already contains data.
    Console.WriteLine(" ============================= ");
    Console.WriteLine("Demonstrate data considerations:");
    Console.WriteLine("Current value, Original value, (RowState)");
    Console.WriteLine(" ============================= ");
    Console.WriteLine("Original table:");

    table = SetupModifiedRows();
    DisplayRowState(table);

    Console.WriteLine(" ============================= ");
    Console.WriteLine("Data in IDataReader to be loaded:");
    DisplayRowState(GetChangedCustomers());

    // Load data into a DataTable, retrieve a DataTableReader 
    // containing different data, and call the Load method. 
    Console.WriteLine(" ============================= ");
    Console.WriteLine("table.Load(reader)");
    Console.WriteLine(" ============================= ");

    table = SetupModifiedRows();
    reader = new DataTableReader(GetChangedCustomers());
    table.Load(reader);
    DisplayRowState(table);

    Console.WriteLine("Press any key to continue.");
    Console.ReadKey();
}

private static void DisplayRowState(DataTable table)
{
    for (int i = 0; i <= table.Rows.Count - 1; i++)
    {
        object current = "--";
        object original = "--";
        DataRowState rowState = table.Rows[i].RowState;

        // Attempt to retrieve the current value, which doesn't exist
        // for deleted rows:
        if (rowState != DataRowState.Deleted)
        {
            current = table.Rows[i]["Name", DataRowVersion.Current];
        }

        // Attempt to retrieve the original value, which doesn't exist
        // for added rows:
        if (rowState != DataRowState.Added)
        {
            original = table.Rows[i]["Name", DataRowVersion.Original];
        }
        Console.WriteLine("{0}: {1}, {2} ({3})", i, 
            current, original, rowState);
    }
}

private static DataTable GetChangedCustomers()
{
    // Create sample Customers table.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", 
        typeof(int));
    table.Columns.Add("Name", typeof(string));

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

    table.Rows.Add(new object[] { 1, "XXX" });
    table.Rows.Add(new object[] { 2, "XXX" });
    table.Rows.Add(new object[] { 3, "XXX" });
    table.Rows.Add(new object[] { 4, "XXX" });
    table.Rows.Add(new object[] { 5, "XXX" });
    table.Rows.Add(new object[] { 6, "XXX" });
    table.AcceptChanges();
    return table;
}

private static DataTable GetCustomers()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", 
        typeof(int));
    table.Columns.Add("Name", typeof(string));

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

    table.Rows.Add(new object[] { 1, "Mary" });
    table.Rows.Add(new object[] { 2, "Andy" });
    table.Rows.Add(new object[] { 3, "Peter" });
    table.Rows.Add(new object[] { 4, "Russ" });
    table.AcceptChanges();
    return table;
}

private static DataTable GetIntegerTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", 
        typeof(int));

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

    table.Rows.Add(new object[] { 5 });
    table.Rows.Add(new object[] { 6 });
    table.Rows.Add(new object[] { 7 });
    table.Rows.Add(new object[] { 8 });
    table.AcceptChanges();
    return table;
}

private static DataTable GetStringTable()
{
    // Create sample Customers table, in order
    // to demonstrate the behavior of the DataTableReader.
    DataTable table = new DataTable();

    // Create two columns, ID and Name.
    DataColumn idColumn = table.Columns.Add("ID", 
        typeof(string));

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

    table.Rows.Add(new object[] { "Mary" });
    table.Rows.Add(new object[] { "Andy" });
    table.Rows.Add(new object[] { "Peter" });
    table.Rows.Add(new object[] { "Russ" });
    table.AcceptChanges();
    return table;
}

private static void PrintColumns(DataTable table)
{
    // Loop through all the rows in the DataTableReader
    foreach (DataRow row in table.Rows)
    {
        for (int i = 0; i < table.Columns.Count; i++)
        {
            Console.Write(row[i] + " ");
        }
        Console.WriteLine();
    }
}

private static DataTable SetupModifiedRows()
{
    // Fill a DataTable with customer info, and 
    // then modify, delete, and add rows.

    DataTable table = GetCustomers();
    // Row 0 is unmodified.
    // Row 1 is modified.
    // Row 2 is deleted.
    // Row 5 is added.
    table.Rows[1]["Name"] = "Sydney";
    table.Rows[2].Delete();
    DataRow row = table.NewRow();
    row["ID"] = 5;
    row["Name"] = "Melony";
    table.Rows.Add(row);

    // Note that the code doesn't call
    // table.AcceptChanges()
    return table;
}

.NET Framework
Disponibile da 2.0
Torna all'inizio
Mostra: