Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. .NET Ayuda
  4. Deedle C#
.NET AYUDA

Deedle C# (Cómo Funciona para Desarrolladores)

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
Actualizado:

Deedle C#

Deedle es una poderosa biblioteca para la manipulación y análisis de datos. Ofrece marcos de datos y series completos, lo que le permite manejar marcos de datos estructurados de manera eficiente. Deedle proporciona herramientas para datos faltantes, alineación de datos y aplicación de funciones auxiliares con miembros estáticos ofNullables y ofObservations. Se utiliza ampliamente en ciencia de datos por su flexibilidad y rendimiento.

IronPDF es una biblioteca para crear y manipular documentos PDF en .NET. Le ayuda a generar PDFs desde HTML, convertir imágenes a PDFs y extraer contenido de archivos PDF. IronPDF simplifica las tareas de PDF en sus proyectos .NET.

En este artículo, aprenderá cómo comenzar con Deedle para C#, configurarlo en sus proyectos .NET usando Visual Studio, e implementar características clave con documentación generada automáticamente. Verá ejemplos de código y explicaciones para ayudarle a entender cómo usar Deedle efectivamente, incluyendo cómo aplicar una función específica.

Cómo empezar con Deedle C#

Configuración de Deedle en proyectos .NET

Para comenzar, cree un nuevo proyecto de aplicación de consola C# en Visual Studio.

Para usar Deedle en su proyecto .NET, necesita instalar el paquete NuGet de Deedle. Ejecute el siguiente comando en la consola de NuGet:

Install-Package Deedle

Una vez instalado, necesita importar el espacio de nombres Deedle en su proyecto:

using Deedle;
using Deedle;
$vbLabelText   $csharpLabel

Un ejemplo de código básico

Comencemos con un ejemplo básico para crear y manipular un marco de datos. Esto le ayudará a entender los conceptos básicos de Deedle.

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);
    }
}
$vbLabelText   $csharpLabel

En este ejemplo, crea una serie con claves de fila enteras y valores dobles. Luego, crea un marco de datos usando una matriz 2D de valores dobles. Índexa las filas con enteros y las columnas con cadenas.

Implementación de las características de Deedle C#

Manejo de valores perdidos

El manejo de valores faltantes es crucial en la manipulación de datos. Deedle proporciona un soporte robusto para datos faltantes. Puede crear una serie con valores faltantes y realizar operaciones para manejarlos.

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);
    }
}
$vbLabelText   $csharpLabel

Este ejemplo crea una serie con valores faltantes y los llena con un valor especificado. También puede usar métodos de miembro estático como ofOptionalObservations y ofValues para escenarios más complejos.

Manipulación de datos

Deedle le permite realizar varias tareas de manipulación de datos. Puede filtrar, transformar y agregar datos en marcos de datos.

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);
    }
}
$vbLabelText   $csharpLabel

Este ejemplo demuestra cómo filtrar filas en base a una condición y agregar una nueva columna con datos transformados. Deedle implementa métodos de extensión de marco estándar para hacer el análisis de datos directo.

Funciones estadísticas

Deedle proporciona funciones estadísticas estándar para analizar datos. Usando las funciones estadísticas, puede calcular el promedio, la desviación estándar y otras medidas estadísticas.

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}");
    }
}
$vbLabelText   $csharpLabel

Este ejemplo de código Deedle implementa funciones estadísticas estándar Mean() y StdDev() para calcular el promedio y la desviación estándar de una serie respectivamente.

Creación de marcos de datos a partir de CSV

Deedle le permite crear marcos de datos fácilmente desde archivos CSV. Esto es útil para cargar y analizar datos estructurados.

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);
    }
}
$vbLabelText   $csharpLabel

Este ejemplo lee un archivo CSV en un marco de datos y realiza una operación de resumen en los datos.

Integración de Deedle con IronPDF

Presentación de IronPDF

Deedle C# (Cómo Funciona Para Desarrolladores): Figura 1 - IronPDF para .NET: La Biblioteca PDF de C#

IronPDF es una poderosa biblioteca que le permite crear, manipular y extraer contenido de archivos PDF en aplicaciones .NET. Es muy versátil y puede manejar varias tareas relacionadas con PDF, como generar PDFs desde HTML, extraer texto, fusionar PDFs y mucho más. Integrar IronPDF con Deedle puede ser particularmente útil para escenarios de análisis de datos e informes donde necesita generar informes dinámicos a partir de marcos de datos.

Instalación de IronPDF

Para instalar IronPDF en su proyecto .NET utilizando la Consola del Administrador de Paquetes NuGet, agregue el siguiente comando:

Install-Package IronPdf

O también puede instalar IronPDF utilizando el Administrador de Paquetes NuGet para Soluciones. Busque el paquete IronPDF en NuGet en los resultados de búsqueda, selecciónelo y luego haga clic en el botón "Instalar". Visual Studio manejará la descarga e instalación automáticamente.

Después de completar la instalación, IronPDF se puede utilizar para su proyecto.

Caso de uso de la fusión de IronPDF con Deedle

Imagina que tienes un marco de datos con algunos datos estadísticos que deseas presentar en un informe PDF. Deedle puede manejar la parte de manipulación y análisis de datos, mientras que IronPDF se puede usar para formatear y generar el informe final. Por ejemplo, puede generar un PDF que incluya tablas, gráficos y estadísticas descriptivas, facilitando la compartición y presentación de datos.

Ejemplo de código del caso de uso

Aquí hay un ejemplo de código completo que muestra cómo integrar Deedle con IronPDF. Crearemos un informe simple a partir de un marco de datos Deedle y generaremos un PDF usando IronPDF.

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

namespace DeedleIronPDFIntegration
{
    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 DeedleIronPDFIntegration
{
    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!");
        }
    }
}
$vbLabelText   $csharpLabel

Resultado

Deedle C# (Cómo Funciona Para Desarrolladores): Figura 2 - PDF de Salida generado usando IronPDF y Deedle

¡Y eso es todo! Acabas de crear una aplicación completamente funcional que toma datos complejos de Deedle y los convierte en un informe PDF formateado usando la Biblioteca PDF .NET de IronPDF. Es una forma poderosa de comunicar los resultados de su análisis de datos en un formato profesional.

Conclusión

En este artículo, hemos explorado cómo integrar Deedle con IronPDF para crear informes PDF dinámicos a partir de marcos de datos. Usando Deedle, puede manipular y analizar datos de manera eficiente, mientras que IronPDF se encarga de la creación y formato del documento PDF final. Esta combinación le permite generar informes profesionales con facilidad, automatizando el proceso del análisis de datos a la presentación.

IronPDF ofrece documentación detallada sobre características y uso junto con varios ejemplos de código de IronPDF para guiarle sobre cómo comenzar y utilizar efectivamente sus características extensas.

Explore las opciones de licenciamiento de IronPDF comenzando desde $799. Pruébelo y vea cómo puede mejorar sus capacidades de informes.

Preguntas Frecuentes

¿Para qué se usa Deedle C#?

Deedle C# se utiliza para la manipulación y análisis de datos, proporcionando herramientas para manejar eficientemente marcos de datos y series estructuradas. Es particularmente útil en aplicaciones de ciencia de datos por su capacidad de gestionar datos faltantes, alinear datos y aplicar funciones.

¿Cómo puedo integrar Deedle con la generación de PDF en .NET?

Puedes integrar Deedle con IronPDF para generar informes PDF dinámicos a partir de marcos de datos. Deedle maneja la manipulación de datos, mientras que IronPDF se utiliza para formatear y generar el informe PDF final, completo con tablas, gráficos y estadísticas.

¿Cómo se instala Deedle en un proyecto .NET?

Para instalar Deedle en un proyecto .NET, puedes usar Visual Studio para crear una nueva aplicación de consola en C#, luego instalar el paquete NuGet de Deedle usando el comando Install-Package Deedle e incluirlo en tu proyecto con using Deedle;.

¿Cuál es el proceso para crear marcos de datos a partir de archivos CSV usando Deedle?

Para crear marcos de datos a partir de archivos CSV usando Deedle, puedes usar el método Frame.ReadCsv(). Esto te permite cargar datos estructurados de archivos CSV en marcos de datos para su análisis y manipulación.

¿Puede Deedle manejar valores faltantes en marcos de datos?

Sí, Deedle ofrece un soporte robusto para manejar valores faltantes en marcos de datos. Puedes usar funciones como FillMissing() para gestionar y completar los datos faltantes apropiadamente dentro de una serie o un marco de datos.

¿Cómo puedo realizar análisis estadístico usando Deedle?

Deedle ofrece funciones estadísticas integradas que te permiten realizar análisis de datos, incluyendo cálculos de media, desviación estándar y otros métricas estadísticas directamente en marcos de datos y series.

¿Cómo se generan informes PDF a partir de marcos de datos en .NET?

Para generar informes PDF a partir de marcos de datos en .NET, puedes usar Deedle para la manipulación de datos e IronPDF para la generación de PDF. Después de manipular los datos con Deedle, usa IronPDF para formatear y presentar los datos en un informe PDF profesionalmente estilizado.

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
  Chatea con el equipo de ingeniería ahora
Director de Tecnología

Jacob Mellor es Director de Tecnología en Iron Software y un ingeniero visionario que lidera la tecnología PDF en C#. Como el desarrollador original detrás de la base de código central de Iron Software, ha moldeado la arquitectura de productos de la compañía desde ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis