C# Datatable to List (How it Works For Developers)

Conversion Using LINQ

The LINQ method is a powerful tool in C# that provides a way to query collections in a declarative manner. Let's take a look at how this can be done.

Define a method as follows:

using System.Linq;
using System.Collections.Generic;

private static List<dynamic> LinqMethod(DataTable dt)
{
    return dt.AsEnumerable().Select(row =>
        new 
        {
            ID = row.Field<int>("ID"),
            Category = row.Field<string>("Category")
        }).ToList();
}

using System.Linq;
using System.Collections.Generic;

private static List<dynamic> LinqMethod(DataTable dt)
{
    return dt.AsEnumerable().Select(row =>
        new 
        {
            ID = row.Field<int>("ID"),
            Category = row.Field<string>("Category")
        }).ToList();
}

In the above code, the extension method AsEnumerable() is called on the DataTable dt. This allows us to use LINQ on each DataRow in the DataTable. The method creates a list of dynamic objects, each representing a row from the DataTable.

Conversion Using foreach Loop

The foreach loop is a tried and tested way to iterate over collections in C#. This method might seem a tad longer, but it's easy to understand and implement.

Here's how it works:

private static List<Category> ForeachMethod(DataTable dt)
{
    List<Category> list = new List<Category>();

    // Iterates through each row within the data table
    foreach (DataRow row in dt.Rows)
    {
        var category = new Category
        {
            ID = Convert.ToInt32(row["ID"]),
            Name = row["Category"].ToString()
        };
        list.Add(category);
    }
    return list;
}

public class Category
{
    public int ID { get; set; }
    public string Name { get; set; }
}

private static List<Category> ForeachMethod(DataTable dt)
{
    List<Category> list = new List<Category>();

    // Iterates through each row within the data table
    foreach (DataRow row in dt.Rows)
    {
        var category = new Category
        {
            ID = Convert.ToInt32(row["ID"]),
            Name = row["Category"].ToString()
        };
        list.Add(category);
    }
    return list;
}

public class Category
{
    public int ID { get; set; }
    public string Name { get; set; }
}

In the ForeachMethod method, the DataTable is iterated over using a foreach loop. For each DataRow, a new Category object is instantiated and added to the list.

Using Reflection to Convert DataTable to List

Reflection is a powerful tool in C# that allows you to inspect the metadata of types at runtime. Let's harness its power:

using System.Reflection;

private static List<T> ConvertDataTableToList<T>(DataTable dt) where T : new()
{
    List<T> list = new List<T>();

    foreach (DataRow row in dt.Rows)
    {
        T obj = new T();
        foreach (DataColumn col in dt.Columns)
        {
            var prop = obj.GetType().GetProperty(col.ColumnName);
            if (prop != null && row[col] != DBNull.Value)
                prop.SetValue(obj, row[col]);
        }
        list.Add(obj);
    }
    return list;
}

using System.Reflection;

private static List<T> ConvertDataTableToList<T>(DataTable dt) where T : new()
{
    List<T> list = new List<T>();

    foreach (DataRow row in dt.Rows)
    {
        T obj = new T();
        foreach (DataColumn col in dt.Columns)
        {
            var prop = obj.GetType().GetProperty(col.ColumnName);
            if (prop != null && row[col] != DBNull.Value)
                prop.SetValue(obj, row[col]);
        }
        list.Add(obj);
    }
    return list;
}

This ConvertDataTableToList method employs reflection, iterating over each DataRow and column in the DataTable. For each column, it searches for a matching property in the generic object and sets its value. This approach allows for a highly reusable method that can convert any DataTable to a list of generic objects.

Usage

To use the above code, simply call the method by specifying the type:

List<Category> categories = ConvertDataTableToList<Category>(dt);

List<Category> categories = ConvertDataTableToList<Category>(dt);

With this method, you're no longer confined to converting specific data tables to specific object types. Instead, you have a versatile tool at your disposal that can handle a variety of data scenarios.

IronPDF: The PDF Powerhouse

When it comes to working with PDFs in C#, IronPDF is a game-changer. Imagine having converted your DataTable to a list and then needing to generate a PDF report from it. IronPDF can effortlessly create, edit, and extract data from PDF documents, streamlining the process of translating your data table-derived information into professional-looking reports.

IronPDF’s main feature is its HTML to PDF functionality, ensuring layouts and styles are preserved. It generates PDFs from web content, suitable for reports, invoices, and documentation. You can convert HTML files, URLs, and HTML strings to PDF files effortlessly.

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");
    }
}

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");
    }
}

IronXL: Excelling in Excel Operations

If your DataTable conversion leads to a need for Excel-related tasks, IronXL is the tool to turn to. This product provides seamless operations for reading, editing, and creating Excel spreadsheets. With the data table-to-list conversion in hand, exporting your data to an Excel format becomes incredibly straightforward with IronXL.

IronOCR: Making Text Recognizable

There might be times when your DataTable consists of image-based data, or you need to extract text from images. This is where IronOCR shines. It allows .NET developers to read text from images, making it a complementary tool if your DataTable conversion operations involve images containing textual information.

IronBarcode: Reading Between the Lines

Finally, IronBarcode is the go-to tool for any barcode operations in your applications. Suppose your DataTable or the list you've converted it to consists of product information with barcodes. In that case, IronBarcode provides an efficient mechanism to read and generate barcodes, bridging the gap between raw product data and scannable barcode information.