Wofür wird Deedle C# verwendet?

Deedle C# wird zur Datenmanipulation und -analyse verwendet und bietet Werkzeuge zur effizienten Handhabung von strukturierten Datenrahmen und Serien. Es ist besonders in Datenwissenschaftsanwendungen nützlich, da es fehlende Daten verwalten, Daten ausrichten und Funktionen anwenden kann.

Wie kann ich Deedle mit der PDF-Erstellung in .NET integrieren?

Sie können Deedle mit IronPDF integrieren, um dynamische PDF-Berichte aus Datenrahmen zu erstellen. Deedle übernimmt die Datenmanipulation, während IronPDF verwendet wird, um den endgültigen PDF-Bericht zu formatieren und zu generieren, komplett mit Tabellen, Diagrammen und Statistiken.

Wie installiert man Deedle in einem .NET-Projekt?

Um Deedle in einem .NET-Projekt zu installieren, können Sie Visual Studio verwenden, um eine neue C#-Konsolenanwendung zu erstellen, dann das Deedle NuGet-Paket mit dem Befehl Install-Package Deedle installieren und es mit using Deedle; in Ihr Projekt einbinden.

Wie erstellt man Datenrahmen aus CSV-Dateien mit Deedle?

Um Datenrahmen aus CSV-Dateien mit Deedle zu erstellen, können Sie die Methode Frame.ReadCsv() verwenden. Dies ermöglicht Ihnen das Laden strukturierter Daten aus CSV-Dateien in Datenrahmen zur Analyse und Manipulation.

Kann Deedle mit fehlenden Werten in Datenrahmen umgehen?

Ja, Deedle bietet robuste Unterstützung für den Umgang mit fehlenden Werten in Datenrahmen. Sie können Funktionen wie FillMissing() verwenden, um fehlende Daten innerhalb einer Serie oder eines Datenrahmens angemessen zu verwalten und zu füllen.

Wie kann ich eine statistische Analyse mit Deedle durchführen?

Deedle bietet eingebaute statistische Funktionen, die es Ihnen ermöglichen, Datenanalysen durchzuführen, einschließlich Berechnungen von Mittelwert, Standardabweichung und anderen statistischen Kennzahlen direkt auf Datenrahmen und Serien.

Wie erzeugt man PDF-Berichte aus Datenrahmen in .NET?

Um PDF-Berichte aus Datenrahmen in .NET zu erzeugen, können Sie Deedle für die Datenmanipulation und IronPDF für die PDF-Erstellung verwenden. Nach der Datenmanipulation mit Deedle verwenden Sie IronPDF, um die Daten in einen professionell gestalteten PDF-Bericht zu formatieren und auszugeben.

What is a practical use case for integrating IronPDF with Deedle?

A practical use case is generating PDF reports for statistical data analysis with Deedle data frames, where IronPDF is used to format and create the final PDF document for professional reports.

Can Deedle be used to manipulate and transform data frames?

Yes, Deedle provides comprehensive support for data manipulation tasks, allowing you to filter, transform, and aggregate data in data frames, making analysis straightforward.

What benefits do IronPDF's features offer for PDF tasks?

IronPDF simplifies PDF tasks such as generating PDFs from HTML, extracting text, and merging PDFs, offering detailed documentation and examples to maximize its use in .NET projects.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

Deedle C# (Funktionsweise für Entwickler)

Jacob Mellor

Updated: 5. Juli 2026

Deedle C#

Deedle ist eine leistungsstarke Bibliothek für Datenmanipulation und Datenanalyse. Es bietet vollständige Datenrahmen und -serien, mit denen Sie strukturierte Datenrahmen effizient verwalten können. Deedle bietet Werkzeuge für fehlende Daten, das Ausrichten von Daten und das Anwenden von Hilfsfunktionen mit statischen Mitgliedern ofNullables und ofObservations. Es wird in der Datenwissenschaft aufgrund seiner Flexibilität und Leistung häufig verwendet.

IronPDF ist eine Bibliothek zum Erstellen und Bearbeiten von PDF-Dokumenten in .NET. Es hilft Ihnen, PDFs aus HTML zu generieren, Bilder in PDFs zu konvertieren und Inhalte aus PDF-Dateien zu extrahieren. IronPDF vereinfacht PDF-Aufgaben in Ihren .NET-Projekten.

In diesem Artikel erfahren Sie, wie Sie mit Deedle für C# loslegen, es in Ihren .NET-Projekten mit Visual Studio einrichten und wichtige Funktionen mit automatisch generierter Dokumentation implementieren. Sie werden Codebeispiele und Erklärungen sehen, die Ihnen helfen zu verstehen, wie Sie Deedle effektiv nutzen können, einschließlich der Anwendung einer spezifizierten Funktion.

Getting Started with Deedle C#

Einrichten von Deedle in .NET-Projekten

Um zu beginnen, erstellen Sie ein neues C#-Konsolenanwendungsprojekt in Visual Studio.

Um Deedle in Ihrem .NET-Projekt zu verwenden, müssen Sie das Deedle-NuGet-Paket installieren. Führen Sie den folgenden Befehl in der NuGet-Konsole aus:

Install-Package Deedle

Install-Package Deedle

PowerShell

Sobald es installiert ist, müssen Sie den Deedle-Namespace in Ihr Projekt importieren:

using Deedle;

using Deedle;

Imports Deedle

Imports Deedle

Ein grundlegendes Code-Beispiel

Beginnen wir mit einem einfachen Beispiel zur Erstellung und Bearbeitung eines Datenrahmens. Dies hilft Ihnen, die Grundlagen von Deedle zu verstehen.

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Creating a series with integer keys and double values
        var series = new Series<int, double>(new[] { 1, 2, 3 }, new[] { 3.5, 4.2, 5.1 });
        Console.WriteLine("Series:");
        Console.WriteLine(series);

        // Creating a data frame from a 2D array
        var rowIndex = new[] { 1, 2, 3 };
        var colIndex = new[] { "A", "B" };
        var data = new double[,] { { 1.0, 3.5 }, { 2.0, 4.2 }, { 3.0, 5.1 } };
        var dataFrame = Frame.FromArray2D(data)
                             .IndexRowsWith(rowIndex)
                             .IndexColumnsWith(colIndex);
        Console.WriteLine("Data Frame:");
        Console.WriteLine(dataFrame);
    }
}

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Creating a series with integer keys and double values
        var series = new Series<int, double>(new[] { 1, 2, 3 }, new[] { 3.5, 4.2, 5.1 });
        Console.WriteLine("Series:");
        Console.WriteLine(series);

        // Creating a data frame from a 2D array
        var rowIndex = new[] { 1, 2, 3 };
        var colIndex = new[] { "A", "B" };
        var data = new double[,] { { 1.0, 3.5 }, { 2.0, 4.2 }, { 3.0, 5.1 } };
        var dataFrame = Frame.FromArray2D(data)
                             .IndexRowsWith(rowIndex)
                             .IndexColumnsWith(colIndex);
        Console.WriteLine("Data Frame:");
        Console.WriteLine(dataFrame);
    }
}

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Creating a series with integer keys and double values
		Dim series As New Series(Of Integer, Double)( { 1, 2, 3 }, { 3.5, 4.2, 5.1 })
		Console.WriteLine("Series:")
		Console.WriteLine(series)

		' Creating a data frame from a 2D array
		Dim rowIndex = { 1, 2, 3 }
		Dim colIndex = { "A", "B" }
		Dim data = New Double(, ) {
			{ 1.0, 3.5 },
			{ 2.0, 4.2 },
			{ 3.0, 5.1 }
		}
		Dim dataFrame = Frame.FromArray2D(data).IndexRowsWith(rowIndex).IndexColumnsWith(colIndex)
		Console.WriteLine("Data Frame:")
		Console.WriteLine(dataFrame)
	End Sub
End Class

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Creating a series with integer keys and double values
		Dim series As New Series(Of Integer, Double)( { 1, 2, 3 }, { 3.5, 4.2, 5.1 })
		Console.WriteLine("Series:")
		Console.WriteLine(series)

		' Creating a data frame from a 2D array
		Dim rowIndex = { 1, 2, 3 }
		Dim colIndex = { "A", "B" }
		Dim data = New Double(, ) {
			{ 1.0, 3.5 },
			{ 2.0, 4.2 },
			{ 3.0, 5.1 }
		}
		Dim dataFrame = Frame.FromArray2D(data).IndexRowsWith(rowIndex).IndexColumnsWith(colIndex)
		Console.WriteLine("Data Frame:")
		Console.WriteLine(dataFrame)
	End Sub
End Class

In diesem Beispiel erstellen Sie eine Serie mit ganzzahligen Zeilenschlüsseln und doppelt genutzten Werten. Dann erstellen Sie einen Datenrahmen mit einem 2D-Array von doppelten Werten. Sie indexieren die Zeilen mit ganzen Zahlen und die Spalten mit Zeichenfolgen.

Implementing Features of Deedle C#

Behandlung fehlender Werte

Der Umgang mit fehlenden Werten ist entscheidend bei der Datenmanipulation. Deedle bietet robuste Unterstützung für fehlende Daten. Sie können eine Serie mit fehlenden Werten erstellen und Operationen zur Handhabung dieser durchführen.

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Creating a series with nullable doubles to represent missing values
        var series = new Series<int, double?>(
            new[] { 75, 8, 47, 5 },
            new double?[] { 75.0, null, 47.0, 5.0 }
        );
        Console.WriteLine("Original Series with Missing Values:");
        Console.WriteLine(series);

        // Fill missing values with a specified value (e.g., 0.0)
        var filledSeries = series.FillMissing(0.0);
        Console.WriteLine("Series after Filling Missing Values:");
        Console.WriteLine(filledSeries);
    }
}

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Creating a series with nullable doubles to represent missing values
        var series = new Series<int, double?>(
            new[] { 75, 8, 47, 5 },
            new double?[] { 75.0, null, 47.0, 5.0 }
        );
        Console.WriteLine("Original Series with Missing Values:");
        Console.WriteLine(series);

        // Fill missing values with a specified value (e.g., 0.0)
        var filledSeries = series.FillMissing(0.0);
        Console.WriteLine("Series after Filling Missing Values:");
        Console.WriteLine(filledSeries);
    }
}

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Creating a series with nullable doubles to represent missing values
		Dim series As New Series(Of Integer, Double?)( { 75, 8, 47, 5 }, New Double?() { 75.0, Nothing, 47.0, 5.0 })
		Console.WriteLine("Original Series with Missing Values:")
		Console.WriteLine(series)

		' Fill missing values with a specified value (e.g., 0.0)
		Dim filledSeries = series.FillMissing(0.0)
		Console.WriteLine("Series after Filling Missing Values:")
		Console.WriteLine(filledSeries)
	End Sub
End Class

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Creating a series with nullable doubles to represent missing values
		Dim series As New Series(Of Integer, Double?)( { 75, 8, 47, 5 }, New Double?() { 75.0, Nothing, 47.0, 5.0 })
		Console.WriteLine("Original Series with Missing Values:")
		Console.WriteLine(series)

		' Fill missing values with a specified value (e.g., 0.0)
		Dim filledSeries = series.FillMissing(0.0)
		Console.WriteLine("Series after Filling Missing Values:")
		Console.WriteLine(filledSeries)
	End Sub
End Class

Dieses Beispiel erstellt eine Serie mit fehlenden Werten und füllt sie mit einem angegebenen Wert. Sie können auch statische Mitgliedsmethoden wie ofOptionalObservations und ofValues für komplexere Szenarien verwenden.

Datenmanipulation

Deedle ermöglicht Ihnen die Durchführung verschiedener Datenmanipulationsaufgaben. Sie können Daten in Datenrahmen filtern, transformieren und aggregieren.

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Creating a data frame
        var rowIndex = new[] { 1, 2, 3 };
        var colIndex = new[] { "A", "B" };
        var data = new double[,] { { 1.0, 3.5 }, { 2.0, 4.2 }, { 3.0, 5.1 } };
        var dataFrame = Frame.FromArray2D(data)
                             .IndexRowsWith(rowIndex)
                             .IndexColumnsWith(colIndex);
        Console.WriteLine("Original Data Frame:");
        Console.WriteLine(dataFrame);

        // Filter rows where column 'A' is greater than 1.5
        var filteredFrame = dataFrame.Where(row => row.Value.GetAs<double>("A") > 1.5);
        Console.WriteLine("Filtered Data Frame:");
        Console.WriteLine(filteredFrame);

        // Add a new column 'C' which is the sum of columns 'A' and 'B'
        dataFrame.AddColumn("C", dataFrame["A"] + dataFrame["B"]);
        Console.WriteLine("Transformed Data Frame with New Column 'C':");
        Console.WriteLine(dataFrame);
    }
}

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Creating a data frame
        var rowIndex = new[] { 1, 2, 3 };
        var colIndex = new[] { "A", "B" };
        var data = new double[,] { { 1.0, 3.5 }, { 2.0, 4.2 }, { 3.0, 5.1 } };
        var dataFrame = Frame.FromArray2D(data)
                             .IndexRowsWith(rowIndex)
                             .IndexColumnsWith(colIndex);
        Console.WriteLine("Original Data Frame:");
        Console.WriteLine(dataFrame);

        // Filter rows where column 'A' is greater than 1.5
        var filteredFrame = dataFrame.Where(row => row.Value.GetAs<double>("A") > 1.5);
        Console.WriteLine("Filtered Data Frame:");
        Console.WriteLine(filteredFrame);

        // Add a new column 'C' which is the sum of columns 'A' and 'B'
        dataFrame.AddColumn("C", dataFrame["A"] + dataFrame["B"]);
        Console.WriteLine("Transformed Data Frame with New Column 'C':");
        Console.WriteLine(dataFrame);
    }
}

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Creating a data frame
		Dim rowIndex = { 1, 2, 3 }
		Dim colIndex = { "A", "B" }
		Dim data = New Double(, ) {
			{ 1.0, 3.5 },
			{ 2.0, 4.2 },
			{ 3.0, 5.1 }
		}
		Dim dataFrame = Frame.FromArray2D(data).IndexRowsWith(rowIndex).IndexColumnsWith(colIndex)
		Console.WriteLine("Original Data Frame:")
		Console.WriteLine(dataFrame)

		' Filter rows where column 'A' is greater than 1.5
		Dim filteredFrame = dataFrame.Where(Function(row) row.Value.GetAs(Of Double)("A") > 1.5)
		Console.WriteLine("Filtered Data Frame:")
		Console.WriteLine(filteredFrame)

		' Add a new column 'C' which is the sum of columns 'A' and 'B'
		dataFrame.AddColumn("C", dataFrame("A") + dataFrame("B"))
		Console.WriteLine("Transformed Data Frame with New Column 'C':")
		Console.WriteLine(dataFrame)
	End Sub
End Class

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Creating a data frame
		Dim rowIndex = { 1, 2, 3 }
		Dim colIndex = { "A", "B" }
		Dim data = New Double(, ) {
			{ 1.0, 3.5 },
			{ 2.0, 4.2 },
			{ 3.0, 5.1 }
		}
		Dim dataFrame = Frame.FromArray2D(data).IndexRowsWith(rowIndex).IndexColumnsWith(colIndex)
		Console.WriteLine("Original Data Frame:")
		Console.WriteLine(dataFrame)

		' Filter rows where column 'A' is greater than 1.5
		Dim filteredFrame = dataFrame.Where(Function(row) row.Value.GetAs(Of Double)("A") > 1.5)
		Console.WriteLine("Filtered Data Frame:")
		Console.WriteLine(filteredFrame)

		' Add a new column 'C' which is the sum of columns 'A' and 'B'
		dataFrame.AddColumn("C", dataFrame("A") + dataFrame("B"))
		Console.WriteLine("Transformed Data Frame with New Column 'C':")
		Console.WriteLine(dataFrame)
	End Sub
End Class

Dieses Beispiel demonstriert das Filtern von Zeilen basierend auf einer Bedingung und das Hinzufügen einer neuen Spalte mit transformierten Daten. Deedle implementiert standardmäßige Frame-Erweiterungsmethoden, um die Datenanalyse einfach zu gestalten.

Statistische Funktionen

Deedle bietet standardmäßige statistische Funktionen zur Analyse von Daten. Mit den statistischen Funktionen können Sie den Durchschnitt, die Standardabweichung und andere statistische Maße berechnen.

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Creating a series with integer keys and double values
        var series = new Series<int, double>(
            new[] { 1, 2, 3, 4 },
            new[] { 1.0, 2.0, 3.0, 4.0 }
        );
        Console.WriteLine("Series:");
        Console.WriteLine(series);

        // Calculate the mean of the series
        var mean = series.Mean();
        Console.WriteLine($"Mean: {mean}");

        // Calculate the standard deviation of the series
        var stddev = series.StdDev();
        Console.WriteLine($"Standard Deviation: {stddev}");
    }
}

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Creating a series with integer keys and double values
        var series = new Series<int, double>(
            new[] { 1, 2, 3, 4 },
            new[] { 1.0, 2.0, 3.0, 4.0 }
        );
        Console.WriteLine("Series:");
        Console.WriteLine(series);

        // Calculate the mean of the series
        var mean = series.Mean();
        Console.WriteLine($"Mean: {mean}");

        // Calculate the standard deviation of the series
        var stddev = series.StdDev();
        Console.WriteLine($"Standard Deviation: {stddev}");
    }
}

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Creating a series with integer keys and double values
		Dim series As New Series(Of Integer, Double)( { 1, 2, 3, 4 }, { 1.0, 2.0, 3.0, 4.0 })
		Console.WriteLine("Series:")
		Console.WriteLine(series)

		' Calculate the mean of the series
		Dim mean = series.Mean()
		Console.WriteLine($"Mean: {mean}")

		' Calculate the standard deviation of the series
		Dim stddev = series.StdDev()
		Console.WriteLine($"Standard Deviation: {stddev}")
	End Sub
End Class

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Creating a series with integer keys and double values
		Dim series As New Series(Of Integer, Double)( { 1, 2, 3, 4 }, { 1.0, 2.0, 3.0, 4.0 })
		Console.WriteLine("Series:")
		Console.WriteLine(series)

		' Calculate the mean of the series
		Dim mean = series.Mean()
		Console.WriteLine($"Mean: {mean}")

		' Calculate the standard deviation of the series
		Dim stddev = series.StdDev()
		Console.WriteLine($"Standard Deviation: {stddev}")
	End Sub
End Class

Dieses Deedle-Codebeispiel implementiert die Standardstatistikfunktionen Mean() und StdDev(), um den Mittelwert und die Standardabweichung einer Serie zu berechnen.

Erstellen von Datenrahmen aus CSV

Deedle ermöglicht es Ihnen, Datenrahmen aus CSV-Dateien einfach zu erstellen. Dies ist nützlich für das Laden und Analysieren von strukturierten Daten.

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Load a data frame from a CSV file
        var dataFrame = Frame.ReadCsv("data.csv");
        Console.WriteLine("Data Frame from CSV:");
        Console.WriteLine(dataFrame);

        // Aggregate rows by a specified column and compute sum
        var summary = dataFrame.AggregateRowsBy<string, double>(
            new[] { "ColumnName" }, // rowKeys
            null, // columnKeys, you can pass null if not required
            v => v.Sum() // aggFunc
        );
        Console.WriteLine("Summary of Data Frame:");
        Console.WriteLine(summary);
    }
}

using System;
using Deedle;

class Program
{
    static void Main()
    {
        // Load a data frame from a CSV file
        var dataFrame = Frame.ReadCsv("data.csv");
        Console.WriteLine("Data Frame from CSV:");
        Console.WriteLine(dataFrame);

        // Aggregate rows by a specified column and compute sum
        var summary = dataFrame.AggregateRowsBy<string, double>(
            new[] { "ColumnName" }, // rowKeys
            null, // columnKeys, you can pass null if not required
            v => v.Sum() // aggFunc
        );
        Console.WriteLine("Summary of Data Frame:");
        Console.WriteLine(summary);
    }
}

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Load a data frame from a CSV file
		Dim dataFrame = Frame.ReadCsv("data.csv")
		Console.WriteLine("Data Frame from CSV:")
		Console.WriteLine(dataFrame)

		' Aggregate rows by a specified column and compute sum
		Dim summary = dataFrame.AggregateRowsBy(Of String, Double)( { "ColumnName" }, Nothing, Function(v) v.Sum())
		Console.WriteLine("Summary of Data Frame:")
		Console.WriteLine(summary)
	End Sub
End Class

Imports System
Imports Deedle

Friend Class Program
	Shared Sub Main()
		' Load a data frame from a CSV file
		Dim dataFrame = Frame.ReadCsv("data.csv")
		Console.WriteLine("Data Frame from CSV:")
		Console.WriteLine(dataFrame)

		' Aggregate rows by a specified column and compute sum
		Dim summary = dataFrame.AggregateRowsBy(Of String, Double)( { "ColumnName" }, Nothing, Function(v) v.Sum())
		Console.WriteLine("Summary of Data Frame:")
		Console.WriteLine(summary)
	End Sub
End Class

Dieses Beispiel liest eine CSV-Datei in einen Datenrahmen ein und führt eine Zusammenfassungsoperation an den Daten durch.

Integration von Deedle mit IronPDF

Einführung in IronPDF

Deedle C# (Wie es für Entwickler funktioniert): Abbildung 1 - IronPDF for .NET: Die C#-PDF-Bibliothek

IronPDF ist eine leistungsstarke Bibliothek, die es Ihnen ermöglicht, Inhalte aus PDF-Dateien in .NET-Anwendungen zu erstellen, zu manipulieren und zu extrahieren. Es ist äußerst vielseitig und kann verschiedene PDF-bezogene Aufgaben wie das Generieren von PDFs aus HTML, Extrahieren von Text, Zusammenführen von PDFs und vieles mehr handhaben. Die Integration von IronPDF mit Deedle kann insbesondere für Datenanalyse- und Berichtsszenarien nützlich sein, bei denen Sie dynamische Berichte aus Datenrahmen generieren müssen.

Installation von IronPDF

Um IronPDF in Ihrem .NET-Projekt mit dem NuGet-Paket-Manager-Konsolenbefehls installieren, fügen Sie den folgenden Befehl hinzu:

PM > Install-Package IronPdf

Install-Package IronPdf

Oder Sie können IronPDF auch über den NuGet-Paket-Manager für Lösungen installieren. Suchen Sie in den Suchergebnissen nach dem IronPDF-Paket auf NuGet, wählen Sie es aus und klicken Sie dann auf die Schaltfläche "Installieren". Visual Studio kümmert sich automatisch um den Download und die Installation.

Nach Abschluss der Installation kann IronPDF in Ihrem Projekt genutzt werden.

Benutzungsfall der Zusammenführung von IronPDF mit Deedle

Stellen Sie sich vor, Sie haben einen Datenrahmen mit einigen statistischen Daten, die Sie in einem PDF-Bericht präsentieren möchten. Deedle kann den Teil der Datenmanipulation und -analyse übernehmen, während IronPDF verwendet werden kann, um den endgültigen Bericht zu formatieren und zu generieren. Zum Beispiel können Sie ein PDF generieren, das Tabellen, Diagramme und deskriptive Statistiken enthält, um die Daten einfach zu teilen und zu präsentieren.

Code-Beispiel für Anwendungsfall

Hier ist ein vollständiges Codebeispiel, das zeigt, wie man Deedle mit IronPDF integriert. Wir erstellen einen einfachen Bericht aus einem Deedle-Datenrahmen und generieren ein PDF mit IronPDF.

using System;
using System.Linq;
using Deedle;
using IronPdf;

namespace Deedle IronPDFIntegration
{
    class Program
    {
        static void Main(string[] args)
        {
            // Set IronPDF license key
            IronPdf.License.LicenseKey = "License-Key";

            // Create a sample data frame from in-memory records
            var data = new[]
            {
                new { Name = "Robert", Age = 30, City = "New York" },
                new { Name = "Johnny", Age = 25, City = "San Francisco" },
                new { Name = "Charlie", Age = 35, City = "Los Angeles" }
            };
            var frame = Frame.FromRecords(data);

            // Convert the data frame to an HTML table format
            var htmlTable = "<table border='1' cellpadding='5' cellspacing='0'><thead><tr><th>Name</th><th>Age</th><th>City</th></tr></thead><tbody>" +
                            string.Join("", frame.Rows.Select(row =>
                                $"<tr><td>{row.Value.GetAs<string>("Name")}</td><td>{row.Value.GetAs<int>("Age")}</td><td>{row.Value.GetAs<string>("City")}</td></tr>")
                            ) +
                            "</tbody></table>";

            // Wrap the HTML table in basic HTML structure with CSS styling
            var htmlContent = $@"
            <html>
            <head>
                <style>
                    table {{width: 100%;
                        border-collapse: collapse;}}
                    th, td {{border: 1px solid black;
                        padding: 8px;
                        text-align: left;}}
                    th {{background-color: #f2f2f2;}}
                </style>
            </head>
            <body>
                {htmlTable}
            </body>
            </html>";

            // Create a PDF from the HTML content
            var renderer = new ChromePdfRenderer();
            var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

            // Save the generated PDF to a file
            pdfDocument.SaveAs("f:\\DeedleReport.pdf");
            Console.WriteLine("PDF report created successfully!");
        }
    }
}

using System;
using System.Linq;
using Deedle;
using IronPdf;

namespace Deedle IronPDFIntegration
{
    class Program
    {
        static void Main(string[] args)
        {
            // Set IronPDF license key
            IronPdf.License.LicenseKey = "License-Key";

            // Create a sample data frame from in-memory records
            var data = new[]
            {
                new { Name = "Robert", Age = 30, City = "New York" },
                new { Name = "Johnny", Age = 25, City = "San Francisco" },
                new { Name = "Charlie", Age = 35, City = "Los Angeles" }
            };
            var frame = Frame.FromRecords(data);

            // Convert the data frame to an HTML table format
            var htmlTable = "<table border='1' cellpadding='5' cellspacing='0'><thead><tr><th>Name</th><th>Age</th><th>City</th></tr></thead><tbody>" +
                            string.Join("", frame.Rows.Select(row =>
                                $"<tr><td>{row.Value.GetAs<string>("Name")}</td><td>{row.Value.GetAs<int>("Age")}</td><td>{row.Value.GetAs<string>("City")}</td></tr>")
                            ) +
                            "</tbody></table>";

            // Wrap the HTML table in basic HTML structure with CSS styling
            var htmlContent = $@"
            <html>
            <head>
                <style>
                    table {{width: 100%;
                        border-collapse: collapse;}}
                    th, td {{border: 1px solid black;
                        padding: 8px;
                        text-align: left;}}
                    th {{background-color: #f2f2f2;}}
                </style>
            </head>
            <body>
                {htmlTable}
            </body>
            </html>";

            // Create a PDF from the HTML content
            var renderer = new ChromePdfRenderer();
            var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

            // Save the generated PDF to a file
            pdfDocument.SaveAs("f:\\DeedleReport.pdf");
            Console.WriteLine("PDF report created successfully!");
        }
    }
}

Ausgabe

Deedle C# (Wie es für Entwickler funktioniert): Abbildung 2 - Ausgabepdf, generiert mit IronPDF und Deedle

Und das war's! Sie haben gerade eine voll funktionsfähige Anwendung erstellt, die komplexe Daten von Deedle nimmt und sie in einem formatierten PDF-Bericht mit der IronPDF's .NET PDF Library umwandelt. Es ist eine leistungsstarke Methode, um Ihre Datenanalyseergebnisse in einem professionellen Format zu kommunizieren.

Abschluss

In diesem Artikel haben wir untersucht, wie man Deedle mit IronPDF integriert, um dynamische PDF-Berichte aus Datenrahmen zu erstellen. Mit Deedle können Sie Daten effizient manipulieren und analysieren, während IronPDF die Erstellung und Formatierung des endgültigen PDF-Dokuments übernimmt. Diese Kombination ermöglicht es Ihnen, professionelle Berichte mit Leichtigkeit zu erstellen und den Prozess von der Datenanalyse bis zur Präsentation zu automatisieren.

IronPDF bietet detaillierte Dokumentation zu Funktionen und Nutzung zusammen mit verschiedenen IronPDF-Codebeispielen zur Orientierung, wie man anfängt und die umfangreichen Funktionen effektiv nutzt.

Erkunden Sie die IronPDF-Lizenzierungsoptionen beginnend bei $999. Probieren Sie es aus und sehen Sie, wie es Ihre Berichtsfähigkeiten verbessern kann.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...