Converting DataTable to List in C#

A menudo, en el ámbito de la programación con C#, surge la necesidad de convertir un DataTable en una lista. Mientras que muchos principiantes tropiezan con esta tarea, a menudo se encuentran con respuestas que simplemente no son lo suficientemente completas. Este tutorial pretende cerrar esa brecha y proporcionar una guía clara sobre cómo convertir un DataTable a una 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. Forma parte del espacio de nombres System.Data.

Para el propósito de este tutorial, usaremos un ejemplo DataTable llamado dt. Esto se puede visualizar como se muestra a continuación:

using System.Data;

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

using System.Data;

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

Imports System.Data

Private 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")

Imports System.Data

Private 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")

Cómo empezar con la conversión

Entonces, tienes tu DataTable dt y ahora estás mirándolo pensando, "¿Cómo convierto esto?". No te preocupes; esa es una pregunta que muestra un esfuerzo de investigación. Principalmente hay dos métodos para convertir DataTable a una lista:

1. Usando LINQ (Language Integrated Query)
2. Usando el clásico bucle foreach

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

'INSTANT VB NOTE: 'Option Strict Off' is used here since dynamic typing is used:
Option Strict Off

Imports System.Linq
Imports System.Collections.Generic

'INSTANT VB NOTE: In the following line, Instant VB substituted 'Object' for 'dynamic' - this will work in VB with Option Strict Off:
Private Shared Function LinqMethod(ByVal dt As DataTable) As List(Of Object)
	Return dt.AsEnumerable().Select(Function(row) New With {
		Key .ID = row.Field(Of Integer)("ID"),
		Key .Category = row.Field(Of String)("Category")
	}).ToList()
End Function

'INSTANT VB NOTE: 'Option Strict Off' is used here since dynamic typing is used:
Option Strict Off

Imports System.Linq
Imports System.Collections.Generic

'INSTANT VB NOTE: In the following line, Instant VB substituted 'Object' for 'dynamic' - this will work in VB with Option Strict Off:
Private Shared Function LinqMethod(ByVal dt As DataTable) As List(Of Object)
	Return dt.AsEnumerable().Select(Function(row) New With {
		Key .ID = row.Field(Of Integer)("ID"),
		Key .Category = row.Field(Of String)("Category")
	}).ToList()
End Function

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 en el DataTable. El método crea una lista de objetos dinámicos, cada uno representando una fila del DataTable.

Conversión usando bucle foreach

El bucle foreach es una forma 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; }
}

Private Shared Function ForeachMethod(ByVal dt As DataTable) As List(Of Category)
	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 With {
			.ID = Convert.ToInt32(row("ID")),
			.Name = row("Category").ToString()
		}
		list.Add(category)
	Next row
	Return list
End Function

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

Private Shared Function ForeachMethod(ByVal dt As DataTable) As List(Of Category)
	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 With {
			.ID = Convert.ToInt32(row("ID")),
			.Name = row("Category").ToString()
		}
		list.Add(category)
	Next row
	Return list
End Function

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

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

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

Después de dominar los conceptos básicos de la conversión de un DataTable a una lista en C#, hay 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.

Usando Reflection para convertir DataTable a 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;
}

Imports System.Reflection

Private Shared Function ConvertDataTableToList(Of T As New)(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
        list.Add(obj)
    Next
    Return list
End Function

Imports System.Reflection

Private Shared Function ConvertDataTableToList(Of T As New)(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
        list.Add(obj)
    Next
    Return list
End Function

Este método ConvertDataTableToList emplea reflexión, iterando sobre cada DataRow y columna en el 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);

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

Dim categories As List(Of Category) = ConvertDataTableToList(Of 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.

Consideraciones sobre el rendimiento

Aunque el método de reflexión es poderoso, vale la pena señalar que puede ser más lento, especialmente con tablas de datos grandes. Siempre es crucial medir el rendimiento y ponderarlo en comparación con los beneficios de reutilización y mantenimiento del código.

Herramientas Iron Suite para desarrolladores .NET

Aunque hemos profundizado en los detalles de la conversión de DataTable a listas en C#, a veces, confiar en 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.

IronPDF: La central de PDF

Cuando se trata de trabajar con PDFs en C#, IronPDF es un cambio total. 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 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");
    }
}

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

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

Si tu conversión de DataTable lleva a la necesidad de tareas relacionadas con Excel, IronXL es la herramienta a la que acudir. 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 que tu DataTable consista en datos basados en imágenes, o necesites extraer texto de imágenes. Aquí es donde IronOCR destaca. Permite a los desarrolladores .NET leer texto de imágenes, convirtiéndolo en una herramienta complementaria si tus operaciones de conversión de DataTable implican 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 tu DataTable o la lista a la que la has convertido consiste en 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.

Conclusión

Mientras que los métodos manuales de manipulación y conversión de DataTable son cruciales para cualquier desarrollador C#, integrar herramientas poderosas como las proporcionadas por Iron Suite puede aumentar exponencialmente tu productividad y capacidades. Es digno de mención que cada licencia de producto comienza desde $999, y lo que es aún más atractivo es que cada producto ofrece una prueba gratuita. Si estás contemplando invertir en estas herramientas, ahí está sobre la mesa una oferta tentadora: puedes adquirir toda la Iron Suite por el precio de solo dos productos. Adoptar soluciones tan completas ciertamente puede elevar la calidad y eficiencia de tus esfuerzos de desarrollo .NET.