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

Im obigen Code wird die Erweiterungsmethode AsEnumerable() auf dem DataTable dt aufgerufen. Dies ermöglicht uns, LINQ auf jedem DataRow im DataTable zu verwenden. Die Methode erstellt eine Liste von dynamischen Objekten, die jeweils eine Zeile aus dem DataTable darstellen.

Umwandlung mit der foreach-Schleife

Die foreach-Schleife ist eine bewährte Methode, 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; }
}

Im ForeachMethod-Verfahren wird das DataTable mithilfe einer foreach-Schleife durchlaufen. Für jedes DataRow wird ein neues Category-Objekt instanziiert und der list hinzugefügt.

Verwendung von Reflection zur Umwandlung 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;
}

Diese ConvertDataTableToList-Methode verwendet Reflection, um über jeden DataRow und jede Spalte im DataTable zu iterieren. 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 jede DataTable in eine Liste von generischen Objekten 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);

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 Ihr DataTable in eine Liste umgewandelt 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");
    }
}

IronXL: Herausragend in Excel-Operationen

Wenn Ihre DataTable-Umwandlung zu Excel-bezogenen Aufgaben führt, ist IronXL das geeignete Werkzeug. 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 könnte Zeiten geben, in denen Ihr DataTable aus bildbasierten Daten besteht oder Sie Text aus Bildern extrahieren müssen. Hier kommt IronOCR ins Spiel. Es ermöglicht .NET-Entwicklern, Text aus Bildern zu lesen, was es zu einem ergänzenden Werkzeug macht, wenn Ihre DataTable-Umwandlungsoperationen Bilder mit Textinformationen umfassen.

IronBarcode: Zwischen den Zeilen lesen

Schließlich ist IronBarcode das Werkzeug der Wahl für alle Barcode-Operationen in Ihren Anwendungen. Angenommen, Ihr DataTable oder die Liste, in die Sie es 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.