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 una DataTable en una lista. Aunque muchos principiantes se tropiezan con esta tarea, a menudo se encuentran con respuestas que no son lo suficientemente completas. Este tutorial tiene como objetivo llenar ese vacío y proporcionar una guía clara sobre cómo convertir DataTable a lista en C#.

¿Qué es una DataTable?

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

Para este tutorial, vamos a utilizar una DataTable de ejemplo llamada DataTable dt. DataTable dt puede visualizarse 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 ya tienes tu DataTable dt, y ahora la estás mirando pensando: "¿Cómo convierto esto?". No se preocupe; es una pregunta que demuestra el esfuerzo de investigación. Existen principalmente dos métodos para convertir DataTable en una lista:

1. Utilizando LINQ (Idioma Consulta integrada)
2. Utilizando 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

Observe el uso de var list, var row y el linqmethod. En el código anterior, el método de extensión AsEnumerable()sobre la tabla de datos dt. Esto nos permite utilizar LINQ en cada filaDataRowde laDataTable`.

Conversión con el bucle `Foreach

El bucle foreach es la forma probada 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 private static void ForeachMethod()se itera sobre la tabla de datos utilizando un bucleforeach`. Para cada fila, se crea un nuevo objeto "var category" y se añade a la lista "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 fundamentos de la conversión de un DataTable a una lista en C#, existen varias técnicas y consideraciones avanzadas 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 anteriores es que son específicos de nuestra clase Category. ¿Y si pudieras escribir un método para convertir cualquier DataTable en una lista de objetos genéricos?

Uso de Reflection para convertir DataTable en 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 la reflexión, iterando sobre cada fila DataRow y columna en la 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 ya nos hemos adentrado en los entresijos de la conversión de DataTable a listas en C#, a veces, recurrir a herramientas externas puede simplificar nuestro proceso de desarrollo, especialmente cuando se trata de operaciones más complejas. Ahí es donde Iron Suite entra en juego.

Iron Suite es un completo conjunto de herramientas diseñadas para facilitar la vida de los desarrolladores .NET. Desde operaciones con PDF y manipulaciones de Excel hasta reconocimiento óptico de caracteres (OCR) y lectura de códigos de barras, Iron Suite ofrece un sinfín de posibilidades. Desglosemos los componentes de Iron Suite y veamos cómo pueden complementar nuestras operaciones DataTable.

IronPDF: La central de PDF

Cuando se trata de trabajar con PDF en C#, IronPDF cambia las reglas del juego. Imagine que ha convertido su DataTable en una lista y luego necesita 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 principal característica de IronPDF es su HTML a PDF garantizando la conservación de 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 su conversión a DataTable conlleva la necesidad de realizar tareas relacionadas con Excel, IronXL es la herramienta a la que hay que 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 brilla. Permite a los desarrolladores .NET leer texto de imágenes, lo que la convierte en una herramienta complementaria si sus operaciones de conversión de DataTable implican imágenes que contienen información textual.

IronBarcode: Leer entre líneas

Por fin, IronBarcode es la herramienta imprescindible para cualquier operación con códigos de barras en sus aplicaciones. Suponga que su DataTable o la lista a la que la 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 de manipulación y conversión de DataTable son cruciales para cualquier desarrollador de C#, la integración de potentes herramientas como las que proporciona Iron Suite puede mejorar exponencialmente su productividad y capacidades. Cabe destacar que la licencia de cada producto comienza a partir de $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 tentadora oferta sobre la mesa: puedes adquirir toda la Iron Suite por el precio de sólo dos productos. La adopción de estas soluciones integrales puede sin duda elevar la calidad y la eficacia de sus esfuerzos de desarrollo .NET.