C# (Comment ça marche pour les développeurs)

Deedle C

Deedle (aiguille) est une bibliothèque puissante pour la manipulation et l'analyse des données. Il offre des cadres de données entiers et des séries, ce qui vous permet de manipuler efficacement des cadres de données structurés. Deedle fournit des outils pour les données manquantes, l'alignement des données et l'application de fonctions d'aide avec les membres statiques ofNullables et ofObservations. Il est largement utilisé dans le domaine de la science des données pour sa flexibilité et ses performances.

IronPDF est une bibliothèque permettant de créer et de manipuler des documents PDF dans .NET. Il vous aide à générer des PDF à partir de HTML, à convertir des images en PDF et à extraire le contenu de fichiers PDF. IronPDF simplifie les tâches liées au format PDF dans vos projets .NET.

Dans cet article, vous apprendrez à démarrer avec Deedle for C#, à l'installer dans vos projets .NET à l'aide de Visual Studio et à mettre en œuvre les principales fonctionnalités avec la documentation générée automatiquement. Vous verrez des exemples de code et des explications qui vous aideront à comprendre comment utiliser Deedle de manière efficace, y compris comment appliquer une fonction spécifique.

Premiers pas avec Deedle C

Mise en place de Deedle dans les projets .NET

Pour commencer, créez un nouveau projet d'application console C# dans Visual Studio.

Pour utiliser Deedle dans votre projet .NET, vous devez installer le paquetage NuGet Deedle. Exécutez la commande suivante dans la console NuGet :

Install-Package Deedle

Une fois installé, vous devez importer l'espace de noms Deedle dans votre projet :

using Deedle;

using Deedle;

Imports Deedle

Un exemple de code de base

Commençons par un exemple de base pour créer et manipuler un cadre de données. Cela vous aidera à comprendre les bases de Deedle.

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dans cet exemple, vous créez une série avec des clés de ligne entières et des valeurs doubles. Ensuite, vous créez un cadre de données à l'aide d'un tableau 2D de valeurs doubles. Vous indexez les lignes avec des nombres entiers et les colonnes avec des chaînes de caractères.

Mise en œuvre des fonctionnalités de Deedle C

Traitement des valeurs manquantes

Le traitement des valeurs manquantes est crucial dans la manipulation des données. Deedle offre un support solide pour les données manquantes. Vous pouvez créer une série avec des valeurs manquantes et effectuer des opérations pour les traiter.

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cet exemple crée une série avec des valeurs manquantes et les remplit avec une valeur spécifiée. Vous pouvez également utiliser des méthodes membres statiques comme ofOptionalObservations et ofValues pour des scénarios plus complexes.

Manipulation de données

Deedle vous permet d'effectuer diverses tâches de manipulation de données. Vous pouvez filtrer, transformer et agréger des données dans des cadres de données.

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cet exemple montre comment filtrer des lignes en fonction d'une condition et ajouter une nouvelle colonne avec des données transformées. Deedle met en œuvre des méthodes d'extension de trame standard pour faciliter l'analyse des données.

Fonctions statistiques

Deedle fournit des fonctions statistiques standard pour analyser les données. Les fonctions statistiques permettent de calculer la moyenne, l'écart-type et d'autres mesures statistiques.

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

Cet exemple de code Deedle met en œuvre les fonctions statistiques standard Mean() et StdDev() pour calculer respectivement la moyenne et l'écart-type d'une série.

Création de cadres de données à partir d'un fichier CSV

Deedle vous permet de créer facilement des cadres de données à partir de fichiers CSV. Cela permet de charger et d'analyser des données structurées.

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

Cet exemple lit un fichier CSV dans un cadre de données et effectue une opération de synthèse sur les données.

Intégrer Deedle à IronPDF

Présentation d'IronPDF

IronPDF est une bibliothèque puissante qui vous permet de créer, de manipuler et d'extraire le contenu de fichiers PDF dans des applications .NET. Il est très polyvalent et peut prendre en charge diverses tâches liées aux PDF, telles que la génération de fichiers PDF PDF à partir de HTMLles logiciels de gestion des documents PDF peuvent être utilisés pour la gestion des documents PDF, l'extraction de texte, la fusion de documents PDF, et bien d'autres choses encore. L'intégration d'IronPDF avec Deedle peut s'avérer particulièrement utile pour les scénarios d'analyse de données et de rapports où vous devez générer des rapports dynamiques à partir de trames de données.

Installation d'IronPDF

Pour installer IronPDF dans votre projet .NET à l'aide de la console NuGet Package Manager, ajoutez la commande suivante :

Install-Package IronPdf

Vous pouvez également installer IronPDF à l'aide de NuGet Package Manager for Solutions. Recherchez le Paquet IronPDF dans les résultats de la recherche, sélectionnez-le, puis cliquez sur le bouton "Installer". Visual Studio se chargera automatiquement du téléchargement et de l'installation.

Une fois l'installation terminée, IronPDF peut être utilisé pour votre projet.

Cas d'utilisation de la fusion d'IronPDF avec Deedle

Imaginez que vous disposiez d'un cadre de données contenant des données statistiques que vous souhaitez présenter dans un rapport PDF. Deedle peut se charger de la manipulation et de l'analyse des données, tandis qu'IronPDF peut être utilisé pour formater et générer le rapport final. Par exemple, vous pouvez générer un PDF comprenant des tableaux, des graphiques et des statistiques descriptives, ce qui facilite le partage et la présentation des données.

Exemple de code pour un cas d'utilisation

Voici un exemple de code complet démontrant comment intégrer Deedle à IronPDF. Nous allons créer un rapport simple à partir d'une base de données Deedle et générer un PDF à l'aide d'IronPDF.

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

Sortie

Et c'est tout! Vous venez de créer une application entièrement fonctionnelle qui utilise des données complexes provenant de Deedle et le transforme en un rapport PDF formaté à l'aide de la fonction IronPDF. C'est un moyen efficace de communiquer les résultats de vos analyses de données dans un format professionnel.

Conclusion

Dans cet article, nous avons exploré la manière d'intégrer les Deedle avec IronPDF pour créer des rapports PDF dynamiques à partir de cadres de données. Deedle vous permet de manipuler et d'analyser efficacement les données, tandis qu'IronPDF se charge de la création et de la mise en forme du document PDF final. Cette combinaison vous permet de générer facilement des rapports professionnels, en automatisant le processus depuis l'analyse des données jusqu'à la présentation.

IronPDF offre des services détaillés de la documentation ainsi que divers exemples de code pour vous aider à démarrer et à utiliser efficacement ses nombreuses fonctionnalités.

Licence IronPDF est disponible à partir de 749 $. Essayez-le et voyez comment il peut améliorer vos capacités de reporting.