Home

repost: C# Datatable (How It Works For Developers Tutorial) | IronPDF

Welcome to this tutorial on C# DataTables. A DataTable is a powerful data structure provided by the .NET framework, which allows you to store, manipulate, and query data in a tabular format. In this tutorial, we will explore the basics of DataTables in C#, including creating and modifying DataTables , adding columns and rows, querying data, and using DataView for filtering and sorting.

By the end of this tutorial, you will have a good understanding of how to use DataTables in your C# applications. Let’s get started!

# Creating a DataTable

To create a DataTable in C#, you first need to import the System.Data namespace. This namespace contains various classes and methods related to data manipulation, including the DataTable class.

1
using System.Data;

Next, you can create an instance of the DataTable class. The simplest way to do this is by using the default constructor, like so:

1
DataTable dt = new DataTable();

You can also create a DataTable with a specific name by passing a string parameter to the constructor:

1
DataTable dt = new DataTable("Employees");

# DataTable Methods

# Adding Columns

Once you have created a DataTable, you can start adding columns to it. To add a column, you first need to create an instance of the DataColumn class and set its properties, such as ColumnName and DataType .

Here’s an example of how to add three columns to a DataTable:

1
2
3
4
5
6
7
DataColumn idColumn = new DataColumn("Id", typeof(int));
DataColumn nameColumn = new DataColumn("Name", typeof(string));
DataColumn ageColumn = new DataColumn("Age", typeof(int));

dt.Columns.Add(idColumn);
dt.Columns.Add(nameColumn);
dt.Columns.Add(ageColumn);

You can add multiple columns like the Id column in the data table.

# Adding Data Rows

After defining the columns, you can start adding rows to the DataTable . To add a row, you need to create a new instance of the DataRow class and populate its fields with the required data.

Here’s an example of how to add a new row to a DataTable :

1
2
3
4
5
6
7
DataRow newRow = dt.NewRow();

newRow["Id"] = 1;
newRow["Name"] = "John Doe";
newRow["Age"] = 30;

dt.Rows.Add(newRow);

You can also add multiple DataTable rows at once using the same method in a loop.

1
2
3
4
5
6
7
8
for (int i = 1; i <= 3; i++)
{
    DataRow row = dt.NewRow();
    row["Id"] = i;
    row["Name"] = "Employee " + i;
    row["Age"] = 20 + i;
    dt.Rows.Add(row);
}

In the above code, we added three data rows.

# Accessing Data

You can access the data stored in a DataTable by iterating through its Rows and Columns collections. Here’s an example of how to display the contents of a DataTable in the console:

1
2
3
4
5
6
7
8
foreach (DataRow row in dt.Rows)
{
    foreach (DataColumn col in dt.Columns)
    {
        Console.Write(row[col] + "\t");
    }
    Console.WriteLine();
}

# Modifying Data

You can modify the data in a DataTable by updating the values in its DataRow objects. Here’s an example of how to update the age of a specific employee:

1
2
3
4
5
DataRow employeeRow = dt.Rows.Find(1); // Find the row with the specified primary key
if (employeeRow != null)
{
    employeeRow["Age"] = 35;
}

# Deleting Rows

You can delete a row from a DataTable by calling the Delete method on a DataRow object:

1
2
3
4
5
6
DataRow employeeRow = dt.Rows.Find(1);
if (employeeRow != null)
{
    employeeRow.Delete();
    dt.AcceptChanges(); // Commit the deletion
}

Keep in mind that calling Delete on a DataRow only marks the row for deletion. You need to call the AcceptChanges method on the DataTable to permanently remove the deleted rows.

# Managing Multiple Tables

In some cases, you might need to work with multiple data tables simultaneously. You can create a dataset variable to store several DataTable objects and manage the relationships between them.

# Querying Data with LINQ

LINQ (Language Integrated Query) is a powerful feature in C# that allows you to query data from various data sources, including DataTable objects. To use LINQ with DataTables, you need to import the System.Linq namespace. Here’s an example of how to filter employees older than 25 using LINQ:

1
2
3
4
5
6
using System.Linq;
var filteredRows = dt.AsEnumerable().Where(row => row.Field<int>("Age") > 25);
foreach (DataRow row in filteredRows)
{
    Console.WriteLine(row["Name"]);
}

# DataView: Sorting and Filtering

DataView is another useful class provided by the System.Data namespace that allows you to create a sorted or filtered view of a DataTable . This is especially useful when you need to display the data in a UI control like a DataGridView . We can also do data binding to add data to the DataGridView control from a DataTable .

Here’s an example of how to create a DataView to filter and sort the employees based on their age:

1
2
3
4
5
6
7
8
9
10
11
DataView view = new DataView(dt);
// Filter employees older than 25
view.RowFilter = "Age > 25";
// Sort by age in descending order
view.Sort = "Age DESC";
// Display the filtered and sorted data
foreach (DataRowView rowView in view)
{
    DataRow row = rowView.Row;
    Console.WriteLine(row["Name"]);
}

# Exporting DataTable to PDF with IronPDF

IronPDF is a powerful HTML to PDF converter, replete with user-friendly PDF-manipulation features enables developers to create, read, and edit PDF documents within .NET applications.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

In this section, we will learn how to export a DataTable to a PDF document using IronPDF.

First, you need to install the IronPDF NuGet package. Open the Package Manager Console in Visual Studio and run the following command:

1
Install-Package IronPdf

Once the package is installed, you can start by importing the necessary namespaces in your code:

1
2
using IronPdf;
using System.IO;

Next, create a helper method that converts the DataTable into an HTML table, as IronPDF uses HTML to render content in PDF documents:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public static string ConvertDataTableToHtml(DataTable dt)
{
    StringBuilder htmlBuilder = new StringBuilder();

    htmlBuilder.AppendLine("<table border='1' cellpadding='5' cellspacing='0'>");
    htmlBuilder.AppendLine("<tr>");

    // Add column headers
    foreach (DataColumn col in dt.Columns)
    {
        htmlBuilder.AppendFormat("<th>{0}</th>", col.ColumnName);
    }

    htmlBuilder.AppendLine("</tr>");

    // Add rows
    foreach (DataRow row in dt.Rows)
    {
        htmlBuilder.AppendLine("<tr>");

        foreach (DataColumn col in dt.Columns)
        {
            htmlBuilder.AppendFormat("<td>{0}</td>", row[col]);
        }

        htmlBuilder.AppendLine("</tr>");
    }

    htmlBuilder.AppendLine("</table>");

    return htmlBuilder.ToString();
}

Now, you can use the HtmlToPdf class provided by IronPDF to render the HTML table and save it as a PDF file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void ExportDataTableToPdf(DataTable dt, string outputPath)
{
    // Convert DataTable to HTML
    string htmlTable = ConvertDataTableToHtml(dt);

    // Create a new HTML to PDF renderer
    var renderer = new ChromePdfRenderer();

    // Set global styles for the table
    renderer.RenderingOptions.CssMediaType = PdfPrintOptions.PdfCssMediaType.Print;
    renderer.RenderingOptions.FirstPageNumber = 1;

    // Render the HTML table as a PDF document
    PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlTable);

    // Save the PDF file
    pdf.SaveAs(outputPath);
}

The ExportDataTableToPdf method creates a DataTable from the HTML table and saves it to the PDF file.

Finally, call the ExportDataTableToPdf method with the appropriate parameters to export your DataTable :

1
2
string pdfOutputPath = "Employees.pdf";
ExportDataTableToPdf(dt, pdfOutputPath);

This will create a PDF file named “Employees.pdf” containing the contents of your DataTable in a tabular format.

C# DataTable (csharp-datatable/csharp-datatable-tutorial-1.webp) - Figure 1

# Conclusion

In this tutorial, you’ve learned the basics of DataTables in C# and how to export a DataTable to a PDF document using the IronPDF library. By incorporating the primary key column, dataset variables, and DataView for filtering and sorting, you will have greater control and flexibility over your data. Now you should have a good understanding of DataTables and how to use IronPDF in conjunction with DataTables to create professional-looking PDF reports in your C# applications.

IronPDF offers a free trial, allowing you to explore its features and capabilities before committing to a purchase.

Edited on