Deedle C# (Wie es für Entwickler funktioniert)

~ Deedle C#

nadeln ist eine leistungsfähige Bibliothek zur Datenmanipulation und Datenanalyse. Es bietet ganze Datenrahmen und -reihen, so dass Sie strukturierte Datenrahmen effizient verarbeiten können. Deedle bietet Werkzeuge für fehlende Daten, das Ausrichten von Daten und die Anwendung von Hilfsfunktionen mit den statischen Mitgliedern ofNullables und ofObservations. Es wird aufgrund seiner Flexibilität und Leistung häufig in der Datenwissenschaft eingesetzt.

ironPDF ist eine Bibliothek zur Erstellung und Bearbeitung von PDF-Dokumenten in .NET. Es hilft Ihnen, PDFs aus HTML zu erzeugen, 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 for C# beginnen, es in Ihren .NET-Projekten mit Visual Studio einrichten und wichtige Funktionen mit automatisch generierter Dokumentation implementieren. Sie werden Code-Beispiele und Erklärungen sehen, die Ihnen helfen zu verstehen, wie Sie Deedle effektiv nutzen können, einschließlich der Anwendung einer bestimmten Funktion.

Erste Schritte mit 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

Nach der Installation müssen Sie den Deedle-Namespace in Ihr Projekt importieren:

using Deedle;

using Deedle;

Imports Deedle

Ein grundlegendes Code-Beispiel

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

using System;
using Deedle;
class Program
{
    static void Main()
    {
        // Creating a series
        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
        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
        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
        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
		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
		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 Reihe mit ganzzahligen Zeilenschlüsseln und doppelten Werten. Anschließend erstellen Sie einen Datenrahmen mit einem 2D-Array von Doppelwerten. Sie indizieren die Zeilen mit Ganzzahlen und die Spalten mit Zeichenketten.

Implementieren von Funktionen von Deedle C

Umgang mit fehlenden Werten

Der Umgang mit fehlenden Werten ist bei der Datenmanipulation von entscheidender Bedeutung. Deedle bietet robuste Unterstützung für fehlende Daten. Sie können eine Reihe mit fehlenden Werten erstellen und Operationen durchführen, um sie zu behandeln.

using System;
using Deedle;
class Program
{
    static void Main()
    {
        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
        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()
    {
        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
        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()
		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
		Dim filledSeries = series.FillMissing(0.0)
		Console.WriteLine("Series after Filling Missing Values:")
		Console.WriteLine(filledSeries)
	End Sub
End Class

In diesem Beispiel wird eine Reihe mit fehlenden Werten erstellt und mit einem bestimmten Wert aufgefüllt. Für komplexere Szenarien können Sie auch statische Methoden wie "ofOptionalObservations" und "ofValues" verwenden.

Datenmanipulation

Mit Deedle können Sie verschiedene Datenmanipulationsaufgaben durchführen. Sie können Daten in Datenrahmen filtern, transformieren und aggregieren.

using System;
using Deedle;
class Program
{
    static void Main()
    {
        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);

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

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

		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 auf der Grundlage einer Bedingung und das Hinzufügen einer neuen Spalte mit transformierten Daten. Deedle implementiert standardmäßige Frame-Erweiterungsmethoden, um die Datenanalyse zu vereinfachen.

Statistische Funktionen

Deedle bietet statistische Standardfunktionen zur Analyse von Daten. Mit den Statistikfunktionen können Sie den Mittelwert, die Standardabweichung und andere statistische Maße berechnen.

using System;
using Deedle;
class Program
{
    static void Main()
    {
        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 mean
        var mean = series.Mean();
        Console.WriteLine($"Mean: {mean}");

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

using System;
using Deedle;
class Program
{
    static void Main()
    {
        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 mean
        var mean = series.Mean();
        Console.WriteLine($"Mean: {mean}");

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

Imports System
Imports Deedle
Friend Class Program
	Shared Sub Main()
		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 mean
		Dim mean = series.Mean()
		Console.WriteLine($"Mean: {mean}")

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

Dieses Deedle-Codebeispiel implementiert die statistischen Standardfunktionen Mittelwert() und StdDev(), um den Mittelwert bzw. die Standardabweichung einer Reihe zu berechnen.

Erstellen von Datenrahmen aus CSV

Mit Deedle können Sie ganz einfach Datenrahmen aus CSV-Dateien erstellen. Dies ist hilfreich beim Laden und Analysieren strukturierter Daten.

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

        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 data frame from CSV file
        var dataFrame = Frame.ReadCsv("data.csv");
        Console.WriteLine("Data Frame from CSV:");
        Console.WriteLine(dataFrame);

        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 data frame from CSV file
		Dim dataFrame = Frame.ReadCsv("data.csv")
		Console.WriteLine("Data Frame from CSV:")
		Console.WriteLine(dataFrame)

		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

In diesem Beispiel wird eine CSV-Datei in einen Datenrahmen eingelesen und eine Zusammenfassungsoperation mit den Daten durchgeführt.

Integration von Deedle mit IronPDF

Einführung von IronPDF

IronPDF ist eine leistungsstarke Bibliothek, mit der Sie PDF-Dateien in .NET-Anwendungen erstellen, bearbeiten und Inhalte daraus extrahieren können. Es ist sehr vielseitig und kann verschiedene PDF-bezogene Aufgaben erledigen, wie z. B. die Erstellung von PDFs aus HTML, Extrahieren von Text, Zusammenführen von PDFs und vieles mehr. Die Integration von IronPDF mit Deedle kann besonders nützlich für Datenanalyse- und Berichtsszenarien sein, bei denen Sie dynamische Berichte aus Datenrahmen erstellen müssen.

Installation von IronPDF

Um IronPDF in Ihrem .NET-Projekt mit der NuGet Package Manager Console zu installieren, fügen Sie den folgenden Befehl hinzu:

Install-Package IronPdf

Sie können IronPDF auch mit dem NuGet Package Manager for Solutions installieren. Suchen Sie nach dem IronPDF-Paket in den Suchergebnissen, wählen Sie es aus und klicken Sie dann auf die Schaltfläche "Installieren". Der Download und die Installation werden von Visual Studio automatisch durchgeführt.

Nach Abschluss der Installation kann IronPDF für Ihr Projekt verwendet werden.

Anwendungsfall 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 darstellen möchten. Deedle kann den Teil der Datenbearbeitung und -analyse übernehmen, während IronPDF für die Formatierung und Erstellung des Abschlussberichts verwendet werden kann. So können Sie beispielsweise eine PDF-Datei mit Tabellen, Diagrammen und deskriptiven Statistiken erstellen, die die Weitergabe und Präsentation der Daten erleichtert.

Code-Beispiel für einen Anwendungsfall

Hier finden Sie ein vollständiges Code-Beispiel, das die Integration von Deedle mit IronPDF demonstriert. Wir werden einen einfachen Bericht aus einem Deedle-Datenrahmen erstellen und mit IronPDF ein PDF generieren.

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

namespace DeedleIronPDFIntegration
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";
            // Create a sample data frame
            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 HTML table
            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
            var renderer = new ChromePdfRenderer();
            var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

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

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

namespace DeedleIronPDFIntegration
{
    class Program
    {
        static void Main(string[] args)
        {
            IronPdf.License.LicenseKey = "License-Key";
            // Create a sample data frame
            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 HTML table
            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
            var renderer = new ChromePdfRenderer();
            var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

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

Imports System
Imports System.Linq
Imports Deedle
Imports IronPdf

Namespace DeedleIronPDFIntegration
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			IronPdf.License.LicenseKey = "License-Key"
			' Create a sample data frame
			Dim data = {
				New With {
					Key .Name = "Robert",
					Key .Age = 30,
					Key .City = "New York"
				},
				New With {
					Key .Name = "Johnny",
					Key .Age = 25,
					Key .City = "San Francisco"
				},
				New With {
					Key .Name = "Charlie",
					Key .Age = 35,
					Key .City = "Los Angeles"
				}
			}
			Dim frame = Frame.FromRecords(data)

			' Convert the data frame to HTML table
			Dim 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(Function(row) $"<tr><td>{row.Value.GetAs(Of String)("Name")}</td><td>{row.Value.GetAs(Of Integer)("Age")}</td><td>{row.Value.GetAs(Of String)("City")}</td></tr>")) & "</tbody></table>"

			' Wrap the HTML table in basic HTML structure with CSS styling
			Dim 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
			Dim renderer = New ChromePdfRenderer()
			Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

			' Save the PDF to file
			pdfDocument.SaveAs("f:\DeedleReport.pdf")
			Console.WriteLine("PDF report created successfully!")
		End Sub
	End Class
End Namespace

Ausgabe

Und das war's! Sie haben gerade eine voll funktionsfähige Anwendung erstellt, die komplexe Daten aus Deedle und verwandelt ihn in einen formatierten PDF-Bericht mit IronPDF. So können Sie die Ergebnisse Ihrer Datenanalyse in einem professionellen Format kommunizieren.

Schlussfolgerung

In diesem Artikel haben wir untersucht, wie man die Deedle mit IronPDF 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. Mit dieser Kombination können Sie mühelos professionelle Berichte erstellen und den Prozess von der Datenanalyse bis zur Präsentation automatisieren.

IronPDF bietet detaillierte dokumentation zusammen mit verschiedenen code-Beispiele um Sie bei den ersten Schritten und der effektiven Nutzung der umfangreichen Funktionen zu unterstützen.

IronPDF-Lizenzierung beginnt bei 749 $. Probieren Sie es aus und sehen Sie, wie es Ihre Berichtsmöglichkeiten verbessern kann.