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

A menudo, en el ámbito de la programación con C#, surge la necesidad de convertir un DataTable en una lista. Aunque muchos novatos se topan con esta tarea, a menudo se encuentran con respuestas que simplemente no son lo suficientemente completas. Este tutorial tiene como objetivo cerrar esa brecha y proporcionar una guía clara sobre cómo convertir DataTable a lista en C#.

¿Qué es un DataTable?

Antes de sumergirse en el proceso de conversión, es crucial entender qué es un DataTable. En C#, un objeto DataTable es una representación de una tabla de base de datos en memoria con filas y columnas. Es parte del espacio de nombres System.Data.

Para el propósito de este tutorial, usemos un DataTable de ejemplo llamado DataTable dt. DataTable dt se puede visualizar como en el siguiente ejemplo de código:

DataTable dt = new DataTable();
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Category", typeof(string));
dt.Rows.Add(1, "Electronics");
dt.Rows.Add(2, "Books");

DataTable dt = new DataTable();
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Category", typeof(string));
dt.Rows.Add(1, "Electronics");
dt.Rows.Add(2, "Books");

Dim dt As New DataTable()
dt.Columns.Add("ID", GetType(Integer))
dt.Columns.Add("Category", GetType(String))
dt.Rows.Add(1, "Electronics")
dt.Rows.Add(2, "Books")

Introducción a la conversión

Así que tienes tu DataTable dt, y ahora lo miras pensando, "¿Cómo lo convierto?". No se preocupe; es una pregunta que demuestra el esfuerzo de investigación. Hay principalmente dos métodos para convertir DataTable en una lista:

1. Utilizando LINQ (Consulta Integrada de Lenguaje)

2. Usando el clásico bucle foreach

Conversión mediante LINQ

El método LINQ es una potente herramienta de C# que permite consultar colecciones de forma declarativa. Veamos cómo hacerlo.

Definir un método como el siguiente ejemplo de código:

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

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

Private Shared Sub LinqMethod(ByVal dt As DataTable)
	Dim list = dt.AsEnumerable().Select(Function(row) New With {
		Key .ID = row.Field(Of Integer)("ID"),
		Key .Category = row.Field(Of String)("Category")
	}).ToList()
End Sub

Tenga en cuenta el uso de var list, var row y el linqmethod. En el código anterior, se llama al método de extensión AsEnumerable() en el DataTable dt. Esto nos permite usar LINQ en cada DataRow row en el DataTable.

Conversión usando un bucle Foreach

El foreach loop es la 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 y aplicar.

Empecemos:

private static void 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();
        category.ID = Convert.ToInt32(row ["ID"]);
        category.Name = row ["Category"].ToString();
        list.Add(category);
    }
}

private static void 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();
        category.ID = Convert.ToInt32(row ["ID"]);
        category.Name = row ["Category"].ToString();
        list.Add(category);
    }
}

Private Shared Sub ForeachMethod(ByVal dt As DataTable)
	Dim list As New List(Of Category)()

	' Iterates through each row within the data table
	For Each row As DataRow In dt.Rows
		Dim category As New Category()
		category.ID = Convert.ToInt32(row ("ID"))
		category.Name = row ("Category").ToString()
		list.Add(category)
	Next row
End Sub

En el método private static void ForeachMethod(), el DataTable se itera utilizando un bucle foreach. Para cada datarow row, se instancia un nuevo objeto var category y se añade a la var list.

Para representar la Categoría, necesitarás una clase:

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

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

Public Class Category
	Public Property ID() As Integer
	Public Property Name() As String
End Class

Ampliación de las técnicas avanzadas de conversión

Después de dominar los conceptos básicos de convertir un DataTable a una lista en C#, existen varias técnicas avanzadas y consideraciones que pueden optimizar este proceso y adaptarlo a escenarios más complejos. Profundicemos en algunas de estas técnicas.

Una de las limitaciones de los métodos discutidos anteriormente es que son específicos de nuestra clase Category. ¿Qué pasaría si pudieras escribir un método para convertir cualquier DataTable en una lista de objetos genéricos?

Uso de Reflection para convertir DataTable a lista

Reflection es una potente herramienta de C# que permite inspeccionar los metadatos de los tipos en tiempo de ejecución. Aprovechemos su potencia

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

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

Private Shared Function ConvertDataTableToList(Of T As New)(ByVal dt As DataTable) As List(Of T)
	Dim list As New List(Of T)()

	For Each row As DataRow In dt.Rows
		Dim obj As New T()
		For Each col As DataColumn In dt.Columns
			Dim prop = obj.GetType().GetProperty(col.ColumnName)
			If prop IsNot Nothing AndAlso row (col) IsNot DBNull.Value Then
				prop.SetValue(obj, row (col))
			End If
		Next col
		list.Add(obj)
	Next row
	Return list
End Function

Este método private static emplea reflexión, iterando sobre cada DataRow row y columna en el DataTable dt. Para cada columna, busca una propiedad coincidente (var prop) 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.

Utilización

Para utilizar el código anterior, basta con llamar al método especificando el tipo:

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

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

Dim categories As List(Of Category) = ConvertDataTableToList(Of Category)(dt)

Con este método, ya no estará limitado a convertir tablas de datos específicas en tipos de objetos específicos. En su lugar, dispondrá de una herramienta versátil que puede manejar una gran variedad de escenarios de datos.

Consideraciones sobre el rendimiento

Aunque el método de reflexión es potente, cabe señalar que puede ser más lento, especialmente con tablas de datos de gran tamaño. Siempre es crucial medir el rendimiento y sopesarlo con las ventajas de la reutilización y el mantenimiento del código.

Kit de herramientas Iron Suite para desarrolladores .NET

Aunque hemos profundizado en las complejidades de convertir DataTable a listas en C#, a veces, depender de herramientas externas puede simplificar nuestro proceso de desarrollo, especialmente cuando se trata de operaciones más complejas. Ahí es donde entra en juego Iron Suite.

Iron Suite es un conjunto integral de herramientas diseñado para facilitar la vida de los desarrolladores .NET. Desde las operaciones de PDF y las manipulaciones de Excel hasta el Reconocimiento Óptico de Caracteres (OCR) y la lectura de códigos de barras, Iron Suite ofrece una miríada de capacidades. Desglosemos los componentes de Iron Suite y veamos cómo pueden complementar nuestras operaciones de DataTable.

IronPDF: La central de PDF

Cuando se trata de trabajar con PDFs en C#, IronPDF es un cambio radical. Imagina haber convertido tu DataTable a una lista y luego necesitar generar un informe PDF a partir de ella. IronPDF puede crear, editar y extraer datos de documentos PDF sin esfuerzo, agilizando el proceso de traducir la información derivada de sus tablas de datos en informes de aspecto profesional.

La característica principal de IronPDF es su funcionalidad de HTML a PDF, asegurando que se preserven los diseños y estilos. Genera archivos PDF a partir de contenidos web, adecuados para informes, facturas y documentación. Puede convertir archivos HTML, URL y cadenas HTML en 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");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

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

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

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

IronXL: Excel en Operaciones

Si la conversión de su DataTable lleva a una necesidad de tareas relacionadas con Excel, IronXL es la herramienta a la que debe recurrir. Este producto proporciona operaciones fluidas de lectura, edición y creación de hojas de cálculo Excel. Con la conversión de tabla de datos a lista en la mano, exportar sus datos a un formato de Excel se vuelve increíblemente sencillo con IronXL.

IronOCR: Reconocimiento de textos

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 de .NET leer texto de imágenes, convirtiéndose en una herramienta complementaria si sus operaciones de conversión de DataTable involucran imágenes que contienen información textual.

IronBarcode: Leer entre líneas

Finalmente, IronBarcode es la herramienta ideal 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 consiste en información de productos con códigos de barras. En ese caso, IronBarcode proporciona un mecanismo eficaz para leer y generar códigos de barras, salvando las distancias entre los datos brutos del producto y la información del código de barras escaneable.

Conclusión

Aunque los métodos manuales para manipular y convertir DataTable son cruciales para cualquier desarrollador de C#, integrar herramientas poderosas como las proporcionadas por Iron Suite puede aumentar exponencialmente tu productividad y capacidades. Es notable que cada licencia de producto comienza desde $749, y lo que es aún más atractivo es que cada producto ofrece una prueba gratuita. Si estás pensando en invertir en estas herramientas, hay una oferta atractiva en la mesa: puedes adquirir el Iron Suite completo por el precio de solo dos productos. La adopción de estas soluciones integrales puede sin duda elevar la calidad y la eficacia de sus esfuerzos de desarrollo .NET.