In this article, we are going to cover the DataTable class in C#.<\/p>\n
Creating a\u00a0 Let’s jump in with an example.<\/p>\n First, let’s declare and instantiate Next, let’s define the structure of our table:<\/p>\n Calling the Now that we’ve created and defined our Let’s apply these steps by adding a record for Microsoft’s stock price.<\/p>\n First, let’s create a Next, let’s update Here, we use the The In addition to the A primary key is defining one or more columns as a unique identifier for records in a table. We can use the Building off our example, let’s create a new column and assign it as the primary key of our table:<\/p>\n First, we’re defining Constraints allow us to set rules to limit what can be inserted into a table. This is beneficial as it guarantees reliability in tables and relationships between multiple tables. In C#, the Let’s look at what constraints exist on our table:<\/p>\n Here, we loop through each item in our table’s Let’s run the code and view the output:<\/p>\n The Let’s clone\u00a0 Next, let’s print out the columns. First, we’ll create a helper method to do this:<\/p>\n Then, we’ll call it on our cloned table:<\/p>\n The output shows the identical column structure:<\/p>\n The Let’s try it on\u00a0 Next, we’ll copy our table, and print out the contents:<\/p>\n The output shows identical data to what we’ve added in The Now, let’s access our new record. We can do this by writing an expression that filters the table by the Next, let’s write a helper method to print out the results:<\/p>\n Finally, we can call this method to view the output of our Which prints out the expected result of the DataTable<\/code> is a data structure that is a member of the System.Data<\/code> namespace. It consists of columns that define the data type and rows that hold individual records, making it ideal for structured data sets. Good use cases include reading information from a relational database or files organized in columns and rows.<\/p>\n<\/a> Create a DataTable and Define the Structure<\/h2>\n
DataTable<\/code> in C# requires two steps:<\/p>\n\n
DataTable<\/code> object<\/li>\nAdd()<\/code> method on the\u00a0Columns<\/code> property<\/li>\n<\/ul>\ndt<\/code>, a DataTable<\/code>:<\/p>\nvar dt = new DataTable();<\/code><\/p>\ndt.Columns.Add(\"Ticker\", typeof(string));\r\ndt.Columns.Add(\"Date\", typeof(DateTime));\r\ndt.Columns.Add(\"Price\", typeof(double));<\/pre>\n
Add()<\/code> method creates a new DataColumn<\/code> object and assigns a reference to it in the Columns<\/code> property of dt<\/code>, our DataTable<\/code>.\u00a0 Passing Ticker<\/code>, Date<\/code> and Price<\/code> as string<\/code> parameters defines the ColumnName<\/code> property of the new columns. We use the typeof<\/code>operator to explicitly define the DataType<\/code> property of our DataColumn<\/code> objects.<\/p>\n<\/a> Populate a DataTable in C#<\/h2>\n
DataTable<\/code>, let’s add some data. There are three steps to adding a record:<\/p>\n\n
DataRow<\/code> object by calling the NewRow()<\/code> method on the DataTable<\/code><\/li>\nDataRow<\/code> by setting each column to the data we want to populate<\/li>\nAdd()<\/code> method on the Rows<\/code> property to add the new DataRow<\/code> to our DataTable<\/code><\/li>\n<\/ul>\nDataRow<\/code> object:<\/p>\nDataRow row = dt.NewRow();<\/code><\/p>\nrow<\/code> by referencing each column to insert the data we want to add:<\/p>\nrow[\"Ticker\"] = \"MSFT\";\r\nrow[\"Date\"] = new DateTime(2023, 3, 3);\r\nrow[\"Price\"] = 255.29;<\/pre>\n
ColumnName<\/code> property of each DataColumn<\/code> object to populate the data. However, we could\u00a0populate the columns by index:<\/p>\nrow[0] = \"MSFT\";\r\nrow[1] = new DateTime(2023, 3, 3);\r\nrow[2] = 255.29;<\/pre>\n
Ordinal<\/code> property of the DataColumn<\/code> object assigns a zero-based int<\/code> index to each column in the order it’s added. Referencing 0<\/code>, 1<\/code> and 2<\/code> has identical behavior to referencing Ticker<\/code>, Date<\/code> and Price<\/code>. We’re just referencing different properties of the same object.<\/p>\n<\/a> Common DataTable Properties<\/h2>\n
Columns<\/code> and Rows<\/code> properties, DataTable<\/code> has a couple of common properties that allow us to apply relational data modeling concepts in memory in C#.<\/p>\n<\/a> Primary Key<\/h3>\n
PrimaryKey<\/code> property to define this in C# with a DataColumn[]<\/code> object<\/code>.<\/p>\nvar pkCol = new DataColumn(\"Key\", typeof(int));\r\ndt.Columns.Add(pkCol);\r\n\r\nvar pkCols = new DataColumn[1];\r\npkCols[0] = pkCol;\r\n\r\ndt.PrimaryKey = pkCols;<\/pre>\n
pkCol<\/code>, a variable referencing Key<\/code>, a new DataColumn<\/code> we’re adding to our table. Next, we create pkCols<\/code>, which is holding a reference to Key<\/code>, the column we want as our primary key. Finally, we’re setting the PrimaryKey<\/code> property to the pkCols<\/code> column array, defining the primary key of our table.<\/p>\n<\/a> Constraints<\/h3>\n
Constraints<\/code> property references a ConstraintsCollection<\/code> object that stores defined constraints.<\/p>\nforeach (Constraint constraint in dt.Constraints)\r\n{\r\n Console.WriteLine(constraint.ConstraintName);\r\n Console.WriteLine(constraint.GetType());\r\n}<\/pre>\nConstraintCollection<\/code> and print the ConstraintName<\/code> and type<\/code>.<\/p>\nConstraint1\r\nSystem.Data.UniqueConstraint<\/pre>\n
Constraint1<\/code> is our only Constraint<\/code> object in our Constraints<\/code> property. It is a UniqueConstraint<\/code> that was automatically created by defining the PrimaryKey<\/code> property for our table. It prevents adding duplicates to our Key<\/code> column, ensuring integrity for the unique identifier of our table.<\/p>\n<\/a> Common Methods of DataTable Class in C#<\/h2>\n
DataTable<\/code> has several common methods that make wrangling structured data sets easy.<\/p>\n<\/a> Clone<\/h3>\n
Clone()<\/code> method takes a copy of the schema and columns but does not copy any of the actual data.<\/p>\ndt<\/code> as an example:<\/p>\nDataTable dtClone = dt.Clone();<\/code><\/p>\npublic static void PrintColumns(DataTable dt)\r\n{\r\n foreach (DataColumn col in dt.Columns)\r\n Console.WriteLine(col.ColumnName);\r\n}<\/pre>\nPrintColumns(dtClone);<\/code><\/p>\nDate\r\nPrice\r\nKey<\/pre>\n
<\/a> Copy<\/h3>\n
Copy()<\/code> method copies a table’s underlying structure and the actual content of the table.<\/p>\ndt<\/code>. First, we’ll create a helper method to print out the content of a\u00a0DataTable<\/code> object:<\/p>\npublic static void PrintData(DataTable dt)\r\n{\r\n foreach (DataRow row in dt.Rows)\r\n {\r\n foreach(DataColumn col in dt.Columns)\r\n {\r\n Console.WriteLine($\"{col}: {row[col]}\");\r\n }\r\n }\r\n}<\/pre>\nDataTable dtCopy = dt.Copy();\r\nPrintData(dtCopy);<\/pre>\n
dt<\/code>:<\/p>\nTicker: MSFT\r\nDate: 3\/3\/2023 12:00:00 AM\r\nPrice: 255.29\r\nKey: 0<\/pre>\n
<\/a> Select<\/h3>\n
Select()<\/code> method allows us to easily access data rows. We can pass a string<\/code> argument with an expression to filter records. Let’s say we add an additional record to dt<\/code>:<\/p>\nrow = dt.NewRow();\r\n\r\nrow[\"Ticker\"] = \"AMZN\";\r\nrow[\"Date\"] = new DateTime(2023, 3, 6);\r\nrow[\"Price\"] = 93.75;\r\nrow[\"Key\"] = 1;\r\n\r\ndt.Rows.Add(row);<\/pre>\n
Ticker<\/code>:<\/p>\nstring expression = \"Ticker='AMZN'\";\r\nDataRow[] result = dt.Select(expression);<\/pre>\n
public static void PrintSelectedRows(DataRow[] rows, DataTable dt)\r\n{\r\n foreach (DataRow dr in rows)\r\n {\r\n foreach (DataColumn col in dt.Columns)\r\n {\r\n Console.WriteLine($\"{col}: {dr[col]}\");\r\n }\r\n }\r\n}<\/pre>\nSelect()<\/code> method call:<\/p>\nPrintSelectedRows(result, dt);<\/code><\/p>\nDataRow<\/code> objects that have a Ticker<\/code> value of AMZN:<\/p>\nTicker: AMZN\r\nDate: 3\/6\/2023 12:00:00 AM\r\nPrice: 93.75\r\nKey: 1<\/pre>\n
<\/a> Practical Example With DataTable Class in C#<\/h2>\n