C# Datentabelle zu Liste (Wie es für Entwickler funktioniert)

Konvertierung mit LINQ

Die LINQ-Methode ist ein mächtiges Werkzeug in C#, das eine deklarative Art und Weise bietet, Sammlungen abzufragen. Werfen wir einen Blick darauf, wie dies gemacht werden kann.

Definieren Sie eine Methode wie folgt:

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

Im obigen Code wird die Erweiterungsmethode AsEnumerable() auf der DataTable dt aufgerufen. Dies ermöglicht es uns, LINQ auf jede DataRow in der DataTable anzuwenden. Die Methode erstellt eine Liste dynamischer Objekte, die jeweils eine Zeile aus der DataTable darstellen.

Umwandlung mit foreach Schleife

Die foreach-Schleife ist ein bewährter Weg, um über Sammlungen in C# zu iterieren. Diese Methode mag etwas länger erscheinen, ist aber leicht zu verstehen und umzusetzen.

So funktioniert es:

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

In der ForeachMethod-Methode wird die DataTable mit einer foreach-Schleife durchlaufen. Für jede DataRow wird ein neues Category-Objekt erstellt und der Liste hinzugefügt.

Nutzung von Reflection zur Umwandlung von DataTable in List

Reflection ist ein mächtiges Werkzeug in C#, das es Ihnen ermöglicht, die Metadaten von Typen zur Laufzeit zu inspizieren. Lassen Sie uns die Kraft nutzen:

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

Diese ConvertDataTableToList-Methode verwendet Reflection und iteriert über jede DataRow und Spalte in der DataTable. Für jede Spalte sucht es nach einer passenden Eigenschaft im generischen Objekt und setzt deren Wert. Dieser Ansatz ermöglicht eine hoch wiederverwendbare Methode, die jede DataTable in eine Liste generischer Objekte umwandeln kann.

Nutzung

Um den obigen Code zu verwenden, rufen Sie einfach die Methode auf, indem Sie den Typ angeben:

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

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

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

Mit dieser Methode sind Sie nicht länger darauf beschränkt, spezifische Datentabellen in spezifische Objekttypen zu konvertieren. Stattdessen haben Sie ein vielseitiges Werkzeug zur Hand, das eine Vielzahl von Datenszenarien bewältigen kann.

IronPDF: Das PDF-Kraftpaket

Wenn es darum geht, mit PDFs in C# zu arbeiten, ist IronPDF ein Game-Changer. Stellen Sie sich vor, Sie haben Ihre DataTable in eine Liste konvertiert und müssen dann einen PDF-Bericht daraus erstellen. IronPDF kann problemlos PDFs erstellen, bearbeiten und Daten daraus extrahieren, und so den Prozess der Übersetzung Ihrer aus der Datentabelle gewonnenen Informationen in professionell aussehende Berichte rationalisieren.

Die Hauptfunktionalität von IronPDF ist seine HTML-zu-PDF-Funktion, die sicherstellt, dass Layouts und Stile beibehalten werden. Es generiert PDFs aus Webinhalt, geeignet für Berichte, Rechnungen und Dokumentation. Sie können HTML-Dateien, URLs und HTML-Strings mühelos in PDF-Dateien konvertieren.

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: Herausragend in Excel-Operationen

Wenn Ihre DataTable-Konvertierung zu einem Bedarf an Excel-bezogenen Aufgaben führt, ist IronXL das Werkzeug, auf das Sie zurückgreifen sollten. Dieses Produkt bietet nahtlose Operationen zum Lesen, Bearbeiten und Erstellen von Excel-Tabellenkalkulationen. Mit der Konvertierung von Datentabellen zu Listen in der Hand wird der Export Ihrer Daten in ein Excel-Format mit IronXL unglaublich einfach.

IronOCR: Text wiedererkennbar machen

Es kann Zeiten geben, in denen Ihre DataTable aus bildbasierten Daten besteht oder Sie Text aus Bildern extrahieren müssen. Hier kommt IronOCR ins Spiel. Es erlaubt .NET-Entwicklern, Text aus Bildern zu lesen und ist ein ergänzendes Werkzeug, wenn Ihre DataTable-Konvertierungsoperationen Bilder mit Textinformationen beinhalten.

IronBarcode: Zwischen den Zeilen lesen

Schließlich ist IronBarcode das Werkzeug der Wahl für alle Barcode-Operationen in Ihren Anwendungen. Angenommen, Ihre DataTable oder die Liste, in die Sie sie konvertiert haben, enthält Produktinformationen mit Barcodes. In diesem Fall bietet IronBarcode einen effizienten Mechanismus zum Lesen und Erzeugen von Barcodes, der die Lücke zwischen Rohproduktdaten und scannbaren Barcodeinformationen schließt.