C# Datatable to List (Cómo funciona para desarrolladores)

Conversión mediante LINQ

El método LINQ es una herramienta poderosa en C# que proporciona una forma de consultar colecciones de manera declarativa. Veamos cómo se puede hacer esto.

Define un método como sigue:

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

En el código anterior, se llama al método de extensión AsEnumerable() en DataTable dt. Esto nos permite usar LINQ en cada DataRow en el DataTable. El método crea una lista de objetos dinámicos, cada uno de los cuales representa una fila de DataTable.

Conversión mediante bucle foreach

El bucle foreach es una forma probada y comprobada de iterar sobre colecciones en C#. Este método puede parecer un poco más largo, pero es fácil de entender e implementar.

Así es como funciona:

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

En el método ForeachMethod, se itera el DataTable mediante un bucle foreach. Por cada DataRow, se instancia un nuevo objeto Category y se añade al list.

Uso de la reflexión para convertir DataTable en lista

La reflexión es una herramienta poderosa en C# que te permite inspeccionar los metadatos de tipos en tiempo de ejecución. Aprovechemos su poder:

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

Este método ConvertDataTableToList emplea reflexión, iterando sobre cada DataRow y columna en DataTable. Para cada columna, busca una propiedad coincidente en el objeto genérico y establece su valor. Este enfoque permite un método altamente reutilizable que puede convertir cualquier DataTable en una lista de objetos genéricos.

Uso

Para usar el código anterior, simplemente llama al método especificando el tipo:

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

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

Con este método, ya no estás limitado a convertir tablas de datos específicas a tipos de objetos específicos. En su lugar, tienes una herramienta versátil a tu disposición que puede manejar una variedad de escenarios de datos.

IronPDF: La central de PDF

Cuando se trata de trabajar con PDFs en C#, IronPDF es un cambio total. Imagínese haber convertido su DataTable en una lista y luego necesitar generar un informe en PDF a partir de él. IronPDF puede crear, editar y extraer datos de documentos PDF sin esfuerzo, agilizando el proceso de traducir la información derivada de tu tabla de datos en informes de aspecto profesional.

La característica principal de IronPDF es su funcionalidad de HTML a PDF, asegurando que se conserven los diseños y estilos. Genera PDFs a partir de contenido web, adecuado para informes, facturas y documentación. Puedes convertir archivos HTML, URLs y cadenas HTML a archivos PDF sin esfuerzo.

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: Sobresaliendo en las operaciones de Excel

Si su conversión de DataTable genera la necesidad de realizar tareas relacionadas con Excel, IronXL es la herramienta a la que recurrir. Este producto proporciona operaciones fluídas para leer, editar y crear hojas de cálculo de Excel. Con la conversión de tabla de datos a lista en mano, exportar tus datos a un formato Excel se vuelve increíblemente sencillo con IronXL.

IronOCR: Cómo hacer que el texto sea reconocible

Puede haber ocasiones en las que su DataTable consista en datos basados ​​en imágenes o necesite extraer texto de imágenes. Aquí es donde IronOCR destaca. Permite a los desarrolladores .NET leer texto de imágenes, lo que lo convierte en una herramienta complementaria si sus operaciones de conversión involucran imágenes que contienen información textual.

IronBarcode: Leyendo entre líneas

Finalmente, IronBarcode es la herramienta de referencia para cualquier operación de código de barras en tus aplicaciones. Supongamos que su DataTable o la lista a la que lo ha convertido consta de información de productos con códigos de barras. En ese caso, IronBarcode proporciona un mecanismo eficiente para leer y generar códigos de barras, cerrando la brecha entre datos de productos crudos y la información de códigos de barras escaneables.