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() für DataTable dt aufgerufen. Dies ermöglicht es uns, LINQ auf jedes DataRow in DataTable anzuwenden. Die Methode erzeugt eine Liste dynamischer Objekte, von denen jedes eine Zeile aus der DataTable darstellt.

Konvertierung mit foreach Schleife

Die foreach Schleife ist eine bewährte Methode, um in C# über Sammlungen 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 Methode ForeachMethod wird die Liste DataTable mithilfe einer Schleife foreach durchlaufen. Für jedes DataRow wird ein neues Category-Objekt instanziiert und der Liste list hinzugefügt.

Verwendung von Reflektion zur Konvertierung von DataTable in eine Liste

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

Diese ConvertDataTableToList Methode verwendet Reflektion und iteriert über jedes DataRow und jede 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 hochgradig wiederverwendbare Methode, die beliebige 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 hätten Ihre DataTable in eine Liste umgewandelt und müssten daraus nun einen PDF-Bericht generieren. 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 richtige Werkzeug dafür. 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 vorkommen, dass Ihre DataTable aus bildbasierten Daten besteht oder dass Sie Text aus Bildern extrahieren müssen. Hier kommt IronOCR ins Spiel. Es ermöglicht .NET Entwicklern, Text aus Bildern zu lesen und ist somit ein ergänzendes Werkzeug, wenn Ihre DataTable Konvertierungsvorgänge 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-Liste oder die Liste, in die Sie sie konvertiert haben, besteht aus 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.