DataTable Classe

Definizione

public ref class DataTable : System::ComponentModel::MarshalByValueComponent, System::ComponentModel::IListSource, System::ComponentModel::ISupportInitialize, System::ComponentModel::ISupportInitializeNotification, System::Runtime::Serialization::ISerializable, System::Xml::Serialization::IXmlSerializable

public ref class DataTable

public ref class DataTable : System::ComponentModel::MarshalByValueComponent, System::ComponentModel::IListSource, System::ComponentModel::ISupportInitialize, System::Runtime::Serialization::ISerializable

public ref class DataTable : System::ComponentModel::MarshalByValueComponent, System::ComponentModel::IListSource, System::ComponentModel::ISupportInitializeNotification, System::Runtime::Serialization::ISerializable, System::Xml::Serialization::IXmlSerializable

[System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitialize, System.ComponentModel.ISupportInitializeNotification, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable

public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitialize, System.ComponentModel.ISupportInitializeNotification, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable

public class DataTable

[System.Serializable]
public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitialize, System.Runtime.Serialization.ISerializable

[System.Serializable]
public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitializeNotification, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable

public class DataTable : System.ComponentModel.MarshalByValueComponent, System.ComponentModel.IListSource, System.ComponentModel.ISupportInitializeNotification, System.Runtime.Serialization.ISerializable, System.Xml.Serialization.IXmlSerializable

[<System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)>]
type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitialize
    interface ISupportInitializeNotification
    interface ISerializable
    interface IXmlSerializable

type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitialize
    interface ISupportInitializeNotification
    interface ISerializable
    interface IXmlSerializable

type DataTable = class

[<System.Serializable>]
type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitialize
    interface ISerializable

[<System.Serializable>]
type DataTable = class
    inherit MarshalByValueComponent
    interface IListSource
    interface ISupportInitializeNotification
    interface ISupportInitialize
    interface ISerializable
    interface IXmlSerializable

Public Class DataTable
Inherits MarshalByValueComponent
Implements IListSource, ISerializable, ISupportInitialize, ISupportInitializeNotification, IXmlSerializable

Public Class DataTable

Public Class DataTable
Inherits MarshalByValueComponent
Implements IListSource, ISerializable, ISupportInitialize

Public Class DataTable
Inherits MarshalByValueComponent
Implements IListSource, ISerializable, ISupportInitializeNotification, IXmlSerializable

Ereditarietà

Object

MarshalByValueComponent

DataTable

Ereditarietà

Object

DataTable

Derivato

System.Data.TypedTableBase<T>

Attributi

DynamicallyAccessedMembersAttribute SerializableAttribute

Implementazioni

IListSource ISupportInitialize ISupportInitializeNotification ISerializable IXmlSerializable

Esempio

Questo esempio illustra come creare manualmente un oggetto DataTable con definizioni di schema specifiche:

• Creare più tabelle DataTable e definire le colonne iniziali.
• Creare i vincoli di tabella.
• Inserire i valori e visualizzare le tabelle.
• Creare le colonne dell'espressione e visualizzare le tabelle.

using System;
using System.Data;

class Program
{
    static void Main()
    {
        // Create two tables and add them into the DataSet.
        DataTable orderTable = CreateOrderTable();
        DataTable orderDetailTable = CreateOrderDetailTable();
        DataSet salesSet = new();
        salesSet.Tables.Add(orderTable);
        salesSet.Tables.Add(orderDetailTable);

        // Set the relations between the tables
        // and create the related constraint.
        salesSet.Relations.Add(
            "OrderOrderDetail",
            orderTable.Columns["OrderId"],
            orderDetailTable.Columns["OrderId"],
            true);

        Console.WriteLine("After creating the foreign key constraint, " +
            "you'll see the following error if you insert " +
            "an order detail with the wrong OrderId:\n");
        try
        {
            DataRow errorRow = orderDetailTable.NewRow();
            errorRow[0] = 1;
            errorRow[1] = "O0007";
            orderDetailTable.Rows.Add(errorRow);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        Console.WriteLine();

        // Insert the rows into the table.
        InsertOrders(orderTable);
        InsertOrderDetails(orderDetailTable);

        Console.WriteLine("The initial Order table.");
        ShowTable(orderTable);

        Console.WriteLine("The OrderDetail table.");
        ShowTable(orderDetailTable);

        // Use the Aggregate-Sum on the child table column to get the result.
        DataColumn colSub = new("SubTotal", typeof(decimal), "Sum(Child.LineTotal)");
        orderTable.Columns.Add(colSub);

        // Compute the tax by referencing the SubTotal expression column.
        DataColumn colTax = new("Tax", typeof(decimal), "SubTotal*0.1");
        orderTable.Columns.Add(colTax);

        // If the OrderId is 'Total', compute the amount due on all orders; otherwise, compute the amount due on this order.
        DataColumn colTotal = new(
            "TotalDue",
            typeof(decimal),
            "IIF(OrderId='Total',Sum(SubTotal)+Sum(Tax),SubTotal+Tax)");
        orderTable.Columns.Add(colTotal);

        DataRow row = orderTable.NewRow();
        row["OrderId"] = "Total";
        orderTable.Rows.Add(row);

        Console.WriteLine("The Order table with the expression columns.");
        ShowTable(orderTable);

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

    private static DataTable CreateOrderTable()
    {
        DataTable orderTable = new("Order");

        // Define the columns one at a time.
        DataColumn colId = new("OrderId", typeof(string));
        orderTable.Columns.Add(colId);

        DataColumn colDate = new("OrderDate", typeof(DateTime));
        orderTable.Columns.Add(colDate);

        // Set the OrderId column as the primary key.
        orderTable.PrimaryKey = [colId];

        return orderTable;
    }

    private static DataTable CreateOrderDetailTable()
    {
        DataTable orderDetailTable = new("OrderDetail");

        // Define all the columns at once.
        DataColumn[] cols =
        [
            new DataColumn("OrderDetailId", typeof(int)),
            new DataColumn("OrderId", typeof(string)),
            new DataColumn("Product", typeof(string)),
            new DataColumn("UnitPrice", typeof(decimal)),
            new DataColumn("OrderQty", typeof(int)),
            new DataColumn("LineTotal", typeof(decimal), "UnitPrice*OrderQty")
        ];

        orderDetailTable.Columns.AddRange(cols);
        orderDetailTable.PrimaryKey = [orderDetailTable.Columns["OrderDetailId"]];
        return orderDetailTable;
    }

    private static void InsertOrders(DataTable orderTable)
    {
        // Add one row at a time.
        DataRow row1 = orderTable.NewRow();
        row1["OrderId"] = "O0001";
        row1["OrderDate"] = new DateTime(2013, 3, 1);
        orderTable.Rows.Add(row1);

        DataRow row2 = orderTable.NewRow();
        row2["OrderId"] = "O0002";
        row2["OrderDate"] = new DateTime(2013, 3, 12);
        orderTable.Rows.Add(row2);

        DataRow row3 = orderTable.NewRow();
        row3["OrderId"] = "O0003";
        row3["OrderDate"] = new DateTime(2013, 3, 20);
        orderTable.Rows.Add(row3);
    }

    private static void InsertOrderDetails(DataTable orderDetailTable)
    {
        // Use an Object array to insert all the rows.
        // Values in the array are matched sequentially to the columns,
        // based on the order in which they appear in the table.
        object[][] rows =
        [
            [1, "O0001", "Mountain Bike", 1419.5, 36],
            [2, "O0001", "Road Bike", 1233.6, 16],
            [3, "O0001", "Touring Bike", 1653.3, 32],
            [4, "O0002", "Mountain Bike", 1419.5, 24],
            [5, "O0002", "Road Bike", 1233.6, 12],
            [6, "O0003", "Mountain Bike", 1419.5, 48],
            [7, "O0003", "Touring Bike", 1653.3, 8],
        ];

        foreach (object[] row in rows)
        {
            orderDetailTable.Rows.Add(row);
        }
    }

    private static void ShowTable(DataTable table)
    {
        foreach (DataColumn col in table.Columns)
        {
            Console.Write("{0,-14}", col.ColumnName);
        }
        Console.WriteLine();

        foreach (DataRow row in table.Rows)
        {
            foreach (DataColumn col in table.Columns)
            {
                if (col.DataType.Equals(typeof(DateTime)))
                    Console.Write("{0,-14:d}", row[col]);
                else if (col.DataType.Equals(typeof(decimal)))
                    Console.Write("{0,-14:C}", row[col]);
                else
                    Console.Write("{0,-14}", row[col]);
            }
            Console.WriteLine();
        }
        Console.WriteLine();
    }
}

' Put the next line into the Declarations section.
private dataSet As DataSet 
 
Private Sub MakeDataTables()
    ' Run all of the functions. 
    MakeParentTable()
    MakeChildTable()
    MakeDataRelation()
    BindToDataGrid()
End Sub
 
Private Sub MakeParentTable()
    ' Create a new DataTable.
    Dim table As New DataTable("ParentTable")

    ' Declare variables for DataColumn and DataRow objects.
    Dim column As DataColumn 
    Dim row As DataRow 
 
    ' Create new DataColumn, set DataType, ColumnName 
    ' and add to DataTable.    
    column = New DataColumn()
    column.DataType = System.Type.GetType("System.Int32")
    column.ColumnName = "id"
    column.ReadOnly = True
    column.Unique = True

    ' Add the Column to the DataColumnCollection.
    table.Columns.Add(column)
 
    ' Create second column.
    column = New DataColumn()
    column.DataType = System.Type.GetType("System.String")
    column.ColumnName = "ParentItem"
    column.AutoIncrement = False
    column.Caption = "ParentItem"
    column.ReadOnly = False
    column.Unique = False

    ' Add the column to the table.
    table.Columns.Add(column)
 
    ' Make the ID column the primary key column.
    Dim PrimaryKeyColumns(0) As DataColumn
    PrimaryKeyColumns(0)= table.Columns("id")
    table.PrimaryKey = PrimaryKeyColumns
 
    ' Instantiate the DataSet variable.
    dataSet = New DataSet()

    ' Add the new DataTable to the DataSet.
    dataSet.Tables.Add(table)
 
    ' Create three new DataRow objects and add 
    ' them to the DataTable
    Dim i As Integer
    For i = 0 to 2
       row = table.NewRow()
       row("id") = i
       row("ParentItem") = "ParentItem " + i.ToString()
       table.Rows.Add(row)
    Next i
End Sub
 
Private Sub MakeChildTable()
    ' Create a new DataTable.
    Dim table As New DataTable("childTable")
    Dim column As DataColumn 
    Dim row As DataRow 
 
    ' Create first column and add to the DataTable.
    column = New DataColumn()
    column.DataType= System.Type.GetType("System.Int32")
    column.ColumnName = "ChildID"
    column.AutoIncrement = True
    column.Caption = "ID"
    column.ReadOnly = True
    column.Unique = True

    ' Add the column to the DataColumnCollection.
    table.Columns.Add(column)
 
    ' Create second column.
    column = New DataColumn()
    column.DataType= System.Type.GetType("System.String")
    column.ColumnName = "ChildItem"
    column.AutoIncrement = False
    column.Caption = "ChildItem"
    column.ReadOnly = False
    column.Unique = False
    table.Columns.Add(column)
 
    ' Create third column.
    column = New DataColumn()
    column.DataType= System.Type.GetType("System.Int32")
    column.ColumnName = "ParentID"
    column.AutoIncrement = False
    column.Caption = "ParentID"
    column.ReadOnly = False
    column.Unique = False
    table.Columns.Add(column)
 
    dataSet.Tables.Add(table)

    ' Create three sets of DataRow objects, five rows each, 
    ' and add to DataTable.
    Dim i As Integer
    For i = 0 to 4
       row = table.NewRow()
       row("childID") = i
       row("ChildItem") = "Item " + i.ToString()
       row("ParentID") = 0 
       table.Rows.Add(row)
    Next i
    For i = 0 to 4
       row = table.NewRow()
       row("childID") = i + 5
       row("ChildItem") = "Item " + i.ToString()
       row("ParentID") = 1 
       table.Rows.Add(row)
    Next i
    For i = 0 to 4
       row = table.NewRow()
       row("childID") = i + 10
       row("ChildItem") = "Item " + i.ToString()
       row("ParentID") = 2 
       table.Rows.Add(row)
    Next i
End Sub
 
Private Sub MakeDataRelation()
    ' DataRelation requires two DataColumn 
    ' (parent and child) and a name.
    Dim parentColumn As DataColumn = _
        dataSet.Tables("ParentTable").Columns("id")
    Dim childColumn As DataColumn = _
        dataSet.Tables("ChildTable").Columns("ParentID")
    Dim relation As DataRelation = new _
        DataRelation("parent2Child", parentColumn, childColumn)
    dataSet.Tables("ChildTable").ParentRelations.Add(relation)
End Sub
 
Private Sub BindToDataGrid()
    ' Instruct the DataGrid to bind to the DataSet, with the 
    ' ParentTable as the topmost DataTable.
    DataGrid1.SetDataBinding(dataSet,"ParentTable")
End Sub

Commenti

La DataTable classe è un oggetto centrale nella libreria ADO.NET. Altri oggetti che usano DataTable includono DataSet e DataView.

DataTable i nomi degli oggetti sono sensibili alla distinzione tra maiuscole e minuscole in modo condizionale. Ad esempio, se uno DataTable è denominato "mydatatable" e un altro "Mydatatable", una stringa usata per cercare una delle tabelle viene considerata sensibile alla distinzione tra maiuscole e minuscole. Tuttavia, se "mydatatable" esiste e "Mydatatable" non lo è, la stringa di ricerca viene considerata senza distinzione tra maiuscole e minuscole. Un DataSet può contenere due oggetti DataTable con lo stesso valore della proprietà TableName, ma con valori della proprietà Namespace diversi. Per altre informazioni sull'utilizzo di DataTable oggetti, vedere Creazione di una tabella Dati.

Se si crea un oggetto DataTable a livello di codice, è prima necessario definirne lo schema aggiungendo DataColumn oggetti a DataColumnCollection (a cui si accede tramite la Columns proprietà ). Per altre informazioni sull'aggiunta di oggetti DataColumn, vedere Aggiunta di colonne a una DataTable.

Per aggiungere righe a un DataTableoggetto , è prima necessario utilizzare il NewRow metodo per restituire un nuovo DataRow oggetto . Il NewRow metodo restituisce una riga con lo schema del DataTable, come definito dalla DataColumnCollection della tabella. Il numero massimo di righe che un DataTable può archiviare è 16.777.216. Per altre informazioni, vedere Aggiunta di dati a un oggetto DataTable.

DataTable Contiene inoltre una raccolta di Constraint oggetti che possono essere utilizzati per garantire l'integrità dei dati. Per ulteriori informazioni, consultare Vincoli della tabella dati.

Esistono molti DataTable eventi che possono essere usati per determinare quando vengono apportate modifiche a una tabella. Questi includono RowChanged, RowChanging, RowDeletinge RowDeleted. Per altre informazioni sugli eventi che possono essere usati con un DataTable, vedere Gestione di eventi DataTable.

Quando viene creata un'istanza di DataTable , alcune delle proprietà di lettura/scrittura vengono impostate sui valori iniziali. Per un elenco di questi valori, vedere il DataTable costruttore.

Considerazioni relative alla sicurezza

Per informazioni sulla sicurezza di DataSet e DataTable, vedere Indicazioni sulla sicurezza.

Thread safety

Questo tipo è sicuro per le operazioni di lettura multithreading. È necessario sincronizzare tutte le operazioni di scrittura.

Vedi anche

• DataTables