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

Oft ergibt sich im Bereich der Programmierung mit C# die Notwendigkeit, eine DataTable in eine Liste zu konvertieren. Während viele Anfänger auf diese Aufgabe stoßen, erhalten sie oft Antworten, die einfach nicht umfassend genug sind. Dieses Tutorial zielt darauf ab, diese Lücke zu schließen und eine klare Anleitung zu geben, wie man DataTable in eine Liste in C# konvertiert.

Was ist eine DataTable?

Bevor wir in den Umwandlungsprozess eintauchen, ist es wichtig zu verstehen, was eine DataTable ist. In C# ist ein DataTable-Objekt eine Darstellung einer In-Memory-Datenbanktabelle mit Zeilen und Spalten. Es ist Teil des System.Data-Namespaces.

Für den Zweck dieses Tutorials verwenden wir ein Beispiel-DataTable mit dem Namen DataTable dt. DataTable dt kann wie im folgenden Codebeispiel visualisiert werden:

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

Erste Schritte bei der Konvertierung

Also, Sie haben Ihre DataTable dt, und nun starren Sie darauf und denken: "Wie konvertiere ich das?". Machen Sie sich keine Sorgen; das ist eine Frage, die den Forschungsaufwand zeigt. Es gibt hauptsächlich zwei Methoden, um DataTable in eine Liste umzuwandeln:

1. Verwendung von LINQ (Language Integrated Query)

2. Verwendung der klassischen foreach-Schleife

Konvertierung mit LINQ

Die LINQ-Methode ist ein leistungsfähiges Tool in C#, mit dem sich Sammlungen auf deklarative Weise abfragen lassen. Schauen wir uns an, wie dies geschehen kann.

Definieren Sie eine Methode wie im folgenden Codebeispiel:

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

Beachten Sie die Verwendung von var list, var row und der linqmethod. Im obigen Code wird die Erweiterungsmethode AsEnumerable() auf dem DataTable dt aufgerufen. Dies ermöglicht uns, LINQ auf jede DataRow row in der DataTable anzuwenden.

Konvertierung mit Foreach-Schleife

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

Fangen wir an:

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

In der Methode private static void ForeachMethod() wird die DataTable mittels einer foreach-Schleife durchlaufen. Für jede datarow row wird ein neues var category-Objekt instanziiert und zur var list hinzugefügt.

Um die Kategorie darzustellen, brauchen Sie eine Klasse:

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

Fortgeschrittene Konvertierungstechniken erweitern

Nachdem Sie die Grundlagen der Umwandlung einer DataTable in eine Liste in C# beherrscht haben, gibt es mehrere fortgeschrittene Techniken und Überlegungen, die diesen Prozess optimieren und an komplexere Szenarien anpassen können. Lassen Sie uns einige dieser Techniken näher beleuchten.

Eine der Einschränkungen der zuvor besprochenen Methoden besteht darin, dass sie spezifisch für unsere Category-Klasse sind. Was wäre, wenn Sie eine Methode schreiben könnten, um eine beliebige DataTable in eine Liste generischer Objekte zu konvertieren?

Verwendung von Reflection zur Umwandlung von DataTable in eine Liste

Reflection ist ein leistungsfähiges Werkzeug in C#, mit dem Sie die Metadaten von Typen zur Laufzeit untersuchen können. Machen wir uns seine Macht zunutze

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

Diese private static Methode verwendet Reflection und iteriert über jede DataRow row und Spalte in der DataTable dt. Für jede Spalte wird nach einer entsprechenden Eigenschaft (var prop) im generischen Objekt gesucht und deren Wert gesetzt. Dieser Ansatz ermöglicht eine hochgradig wiederverwendbare Methode, die jede DataTable in eine Liste generischer Objekte umwandeln kann.

Verwendung

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 mehr auf die Konvertierung bestimmter Datentabellen in bestimmte Objekttypen beschränkt. Stattdessen steht Ihnen ein vielseitiges Werkzeug zur Verfügung, das eine Vielzahl von Datenszenarien verarbeiten kann.

Überlegungen zur Leistung

Die Reflection-Methode ist zwar mächtig, aber vor allem bei großen Datentabellen kann sie langsamer sein. Es ist immer wichtig, die Leistung zu messen und sie gegen die Vorteile der Wiederverwendbarkeit und Wartbarkeit des Codes abzuwägen.

Iron Suite Toolkit für .NET-Entwickler

Während wir uns mit den Feinheiten der Umwandlung von DataTable in Listen in C# befasst haben, kann die Nutzung externer Tools manchmal unseren Entwicklungsprozess vereinfachen, insbesondere bei komplexeren Vorgängen. Das ist, wo Iron Suite ins Spiel kommt.

Iron Suite ist eine umfassende Suite von Tools, die entwickelt wurde, um das Leben von .NET-Entwicklern zu erleichtern. Von PDF-Operationen und Excel-Manipulationen bis hin zur optischen Zeichenerkennung (OCR) und Barcode-Lesen bietet Iron Suite eine Vielzahl von Fähigkeiten. Lassen Sie uns die Komponenten der Iron Suite aufschlüsseln und sehen, wie sie unsere DataTable-Operationen ergänzen können.

IronPDF: Das PDF-Kraftpaket

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

Die Hauptfunktion von IronPDF ist die HTML-zu-PDF-Funktionalität, die sicherstellt, dass Layouts und Stile erhalten bleiben. Es erzeugt PDFs aus Webinhalten, die sich für Berichte, Rechnungen und Dokumentationen eignen. Sie können HTML-Dateien, URLs und HTML-Strings mühelos in PDF-Dateien umwandeln.

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: Herausragende Excel-Operationen

Wenn Ihre DataTable-Konvertierung zu 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-Tabellen. Mit der Konvertierung von Datentabellen in Listen ist der Export Ihrer Daten in ein Excel-Format mit IronXL ein Kinderspiel.

IronOCR: Text erkennbar machen

Es kann vorkommen, dass Ihr DataTable bildbasierte Daten enthält oder Sie Text aus Bildern extrahieren müssen. Hier kommt IronOCR zur Geltung. Es ermöglicht .NET-Entwicklern, Text aus Bildern zu lesen, was es zu einem ergänzenden Werkzeug macht, wenn Ihre DataTable-Konvertierungsoperationen Bilder mit Textinformationen beinhalten.

IronBarcode: Zwischen den Zeilen lesen

Schließlich ist IronBarcode das ideale Werkzeug für alle Barcode-Operationen in Ihren Anwendungen. Angenommen, Ihre DataTable oder die Liste, in die Sie sie umgewandelt haben, besteht aus Produktinformationen mit Barcodes. In diesem Fall bietet IronBarcode einen effizienten Mechanismus zum Lesen und Generieren von Barcodes und schließt die Lücke zwischen Produktrohdaten und scanbaren Barcode-Informationen.

Schlussfolgerung

Während die manuellen Methoden zur Manipulation und Konvertierung von DataTable entscheidend für jeden C#-Entwickler sind, kann die Integration leistungsstarker Tools wie der von Iron Suite bereitgestellten Ihre Produktivität und Fähigkeiten exponentiell steigern. Es ist bemerkenswert, dass jede Produktlizenz bei $749 beginnt, und was noch ansprechender ist, ist, dass jedes Produkt eine kostenlose Testversion anbietet. Wenn Sie in Erwägung ziehen, in diese Tools zu investieren, gibt es ein verlockendes Angebot: Sie können die gesamte Iron Suite zum Preis von nur zwei Produkten erwerben. Der Einsatz solcher umfassenden Lösungen kann zweifellos die Qualität und Effizienz Ihrer .NET-Entwicklungsbemühungen steigern.