AYUDA .NET

Livecharts C# (Cómo funciona para desarrolladores)

Actualizado 29 de abril, 2024
Compartir:

LiveCharts es una biblioteca para desarrolladores .NET. LiveCharts ayuda a crear gráficos dinámicos y de belleza en aplicaciones C#. Esto significa que los gráficos se actualizan automáticamente cuando cambian los datos. LiveCharts no es sólo para aplicaciones tradicionales. Es compatible con Windows Presentation Foundation (WPF). Esto la convierte en una herramienta versátil para aplicaciones de escritorio.

Principales características y ventajas

¿Busca una respuesta a sus necesidades de visualización de datos? LiveCharts ofrece una solución integral. LiveCharts ofrece una amplia gama de funciones. He aquí algunos puntos clave:

  • Animaciones automáticas: El gráfico se anima automáticamente, actualizándose sin problemas y sin necesidad de código adicional, lo que hace que sus visualizaciones de datos sean más atractivas.
  • Soporte WPF: Puede utilizar LiveCharts en aplicaciones WPF. Esto permite crear interfaces de usuario enriquecidas.
  • Alto rendimiento: Diseñado para mejorar el rendimiento, la velocidad y la eficiencia, especialmente con grandes conjuntos de datos.
  • Flexibilidad: Es sencillo, flexible, interactivo y fácil desde el principio, pero también permite complejas personalizaciones adaptadas a las necesidades de tu proyecto.
  • Gráficos interactivos: Los usuarios pueden interactuar con los gráficos. Esto hace que la exploración de datos sea intuitiva.
  • Amplia gama de tipos de gráficos: Sean cuales sean sus necesidades de visualización de datos, LiveCharts tiene un tipo de gráfico para ello.

    LiveCharts convierte datos complejos en representaciones visuales interactivas y atractivas. Su facilidad de uso y flexibilidad la convierten en una potente herramienta para desarrolladores. Utilizando las capacidades de los potentes LiveCharts, los desarrolladores pueden convertir datos complejos en representaciones visuales interactivas y atractivas. Exploraremos las características de LiveCharts y su integración con el Biblioteca IronPDF.

Primeros pasos con LiveCharts

Configurar su entorno de desarrollo para utilizar LiveCharts es sencillo, y acceder a su código fuente mejora la personalización y la comprensión. Esta sección le guía a través de los pasos iniciales y le ayuda a crear su primer gráfico.

Configuración del entorno

Para utilizar LiveCharts, asegúrese de tener instalado Visual Studio. A continuación, añada a su proyecto el paquete LiveCharts, un paquete diseñado para la visualización dinámica de datos. Puede hacerlo a través del gestor de paquetes NuGet. Busca LiveCharts e instala la última versión. Este proceso añade todas las referencias necesarias a su proyecto.

Su primer gráfico con LiveCharts

La creación de su primer gráfico requiere unos sencillos pasos. En primer lugar, añada un control de gráfico a la interfaz de usuario de su aplicación. Si utiliza WPF, puede hacerlo en XAML o mediante programación en C#.

He aquí un ejemplo básico en XAML:

<lvc:CartesianChart Series="{Binding MySeries}"/>
<lvc:CartesianChart Series="{Binding MySeries}"/>
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'<lvc:CartesianChart Series="{Binding MySeries}"/>
VB   C#

En su código C#, prepare los datos para su gráfico. Para un gráfico de líneas básico, necesitará una SeriesCollection. Puede rellenar esta colección con LineSeries, estableciendo los Values a sus puntos de datos.

public SeriesCollection MySeries { get; set; }
public MainWindow()
{
    InitializeComponent();
    MySeries = new SeriesCollection
    {
        new LineSeries
        {
            Values = new ChartValues<double> { 4, 6, 5, 2, 7 }
        }
    };
    DataContext = this;
}
public SeriesCollection MySeries { get; set; }
public MainWindow()
{
    InitializeComponent();
    MySeries = new SeriesCollection
    {
        new LineSeries
        {
            Values = new ChartValues<double> { 4, 6, 5, 2, 7 }
        }
    };
    DataContext = this;
}
Public Property MySeries() As SeriesCollection
'INSTANT VB WARNING: The following constructor is declared outside of its associated class:
'ORIGINAL LINE: public MainWindow()
Public Sub New()
	InitializeComponent()
	MySeries = New SeriesCollection
		From {
			New LineSeries With {
				.Values = New ChartValues(Of Double) From {4, 6, 5, 2, 7}
			}
		}
	DataContext = Me
End Sub
VB   C#

Este fragmento de código crea un simple gráfico de líneas. Muestra una serie de valores en un gráfico cartesiano. Recuerde establecer el DataContext de su ventana o control para asegurar que el gráfico se vincula a sus datos.

Siguiendo estos pasos, tendrás un gráfico básico en funcionamiento. Esto es sólo el principio. LiveCharts permite realizar visualizaciones de datos mucho más complejas e interactivas.

Explorar las funciones de LiveCharts

LiveCharts no se limita a mostrar datos estáticos. Su verdadero poder reside en su capacidad para actualizarse en tiempo real, reaccionar a los cambios de datos y ofrecer una amplia gama de tipos de gráficos. Esta sección profundiza en estas capacidades y ofrece ejemplos que le ayudarán a comprender los conceptos.

Comprender la vinculación de datos y las actualizaciones

La vinculación de datos es un concepto fundamental en LiveCharts. Permite que los gráficos reflejen automáticamente los cambios en los datos. Esta función es especialmente útil para las aplicaciones que trabajan con fuentes de datos dinámicas.

Imaginemos una aplicación de seguimiento de cotizaciones bursátiles. A medida que se reciben nuevos datos, el gráfico debe actualizarse. Con LiveCharts, basta con actualizar la fuente de datos. El gráfico detecta estos cambios y se actualiza en consecuencia.

A continuación se explica cómo vincular un gráfico a una fuente de datos:

var myValues = new ChartValues<double> { 3, 4, 6, 3, 2 };
var lineSeries = new LineSeries
{
    Values = myValues
};
mySeries.Add(lineSeries);
//  Cuando cambian los datos
myValues.Add(5); //  El gráfico se actualiza automáticamente
var myValues = new ChartValues<double> { 3, 4, 6, 3, 2 };
var lineSeries = new LineSeries
{
    Values = myValues
};
mySeries.Add(lineSeries);
//  Cuando cambian los datos
myValues.Add(5); //  El gráfico se actualiza automáticamente
Dim myValues = New ChartValues(Of Double) From {3, 4, 6, 3, 2}
Dim lineSeries As New LineSeries With {.Values = myValues}
mySeries.Add(lineSeries)
'  Cuando cambian los datos
myValues.Add(5) '  El gráfico se actualiza automáticamente
VB   C#

Livecharts C# (Cómo funciona para desarrolladores): Figura 1

Tipos de gráficos

LiveCharts admite varios tipos de gráficos, cada uno adecuado para diferentes tipos de necesidades de visualización de datos. He aquí algunos ejemplos:

  • Serie de líneas: Ideal para mostrar tendencias a lo largo del tiempo.
  • Gráfico de pastel: El mejor para mostrar proporciones en un conjunto de datos.
  • Gráfico de barras: Útil para comparar cantidades entre diferentes categorías.

    Para crear un gráfico circular, se utiliza la clase PieSeries. He aquí un ejemplo rápido:

public SeriesCollection MyPieSeries { get; set; }
public MainWindow()
{
    InitializeComponent();
    MyPieSeries = new SeriesCollection
    {
        new PieSeries
        {
            Values = new ChartValues<double> { 4, 6, 5 },
            Title = "Series 1"
        },
        new PieSeries
        {
            Values = new ChartValues<double> { 7, 8, 6 },
            Title = "Series 2"
        }
    };
    DataContext = this;
}
public SeriesCollection MyPieSeries { get; set; }
public MainWindow()
{
    InitializeComponent();
    MyPieSeries = new SeriesCollection
    {
        new PieSeries
        {
            Values = new ChartValues<double> { 4, 6, 5 },
            Title = "Series 1"
        },
        new PieSeries
        {
            Values = new ChartValues<double> { 7, 8, 6 },
            Title = "Series 2"
        }
    };
    DataContext = this;
}
Public Property MyPieSeries() As SeriesCollection
'INSTANT VB WARNING: The following constructor is declared outside of its associated class:
'ORIGINAL LINE: public MainWindow()
Public Sub New()
	InitializeComponent()
	MyPieSeries = New SeriesCollection
		From {
			New PieSeries With {
				.Values = New ChartValues(Of Double) From {4, 6, 5},
				.Title = "Series 1"
			},
			New PieSeries With {
				.Values = New ChartValues(Of Double) From {7, 8, 6},
				.Title = "Series 2"
			}
		}
	DataContext = Me
End Sub
VB   C#

Este fragmento de código configura un gráfico circular básico con dos series de datos. Como en el ejemplo del gráfico de líneas, vincula la propiedad PieSeries a la propiedad Values.

Livecharts C# (Cómo funciona para desarrolladores): Figura 2

LiveCharts también ofrece flexibilidad y control sobre la apariencia y el comportamiento de sus gráficos. Puede personalizar casi todos los aspectos, desde los colores y las etiquetas hasta las animaciones y la interactividad. Esto permite adaptar perfectamente los gráficos al aspecto de la aplicación.

Introducción a IronPDF

La integración de LiveCharts con IronPDF tiende un puente entre la visualización dinámica de datos y la generación estática de informes. IronPDF es una potente biblioteca para C# que permite a los desarrolladores crear, manipular y convertir documentos PDF mediante programación.

Combinarlo con LiveCharts permite crear informes en PDF que contienen sus gráficos interactivos. Esta sección presenta IronPDF y le guía sobre cómo configurarlo en su proyecto.

¿Por qué IronPDF?

IronPDF sobresale donde otras bibliotecas PDF se quedan cortas, especialmente en su capacidad para renderizar HTML a PDF. Esta función resulta especialmente útil cuando se trabaja con LiveCharts, ya que permite representar los gráficos en lienzos HTML y convertirlos después en documentos PDF. IronPDF es totalmente compatible con CSS3, JavaScript y HTML5, lo que garantiza que sus gráficos tengan el aspecto deseado en el PDF.

LiveCharts con IronPDF

A continuación se muestra un ejemplo de código detallado que ilustra el proceso de creación de un gráfico con LiveCharts, su exportación y, a continuación, el uso de IronPDF para generar un informe PDF que incluya este gráfico. Este ejemplo asume que usted tiene una comprensión básica de cómo trabajar con LiveCharts y IronPDF.

En primer lugar, asegúrese de que tiene los paquetes LiveCharts e IronPDF instalados en su proyecto a través de NuGet.

Paso 1: Generar el gráfico con LiveCharts

Empecemos por crear un sencillo gráfico de líneas utilizando LiveCharts. Para simplificar, este ejemplo se centrará en generar el gráfico y guardarlo como una imagen, que posteriormente se incluirá en nuestro PDF.

private void GenerateChartButton_Click(object sender, RoutedEventArgs e)
{
    CreateAndSaveChartImage();
}
public void CreateAndSaveChartImage()
{
    var seriesCollection = new SeriesCollection
{
    new LineSeries
    {
        Values = new ChartValues<double> { 4, 6, 5, 2, 7 },
        Title = "Sample Series"
        //  Asegúrese de configurar las propiedades de las series, como el color, la geometría de los puntos, etc.
    }
};
    var chart = new CartesianChart
    {
        Series = seriesCollection,
        Width = 400,
        Height = 300,
        Background = Brushes.White
    };
    //  Añadir gráfico a la interfaz de usuario
    ChartContainer.Child = chart;
    chart.Update(true, true); //  Forzar el redibujado del gráfico
    SaveChartToImage(chart);
}
private void SaveChartToImage(CartesianChart chart)
{
    //  Asegúrese de que el diseño del gráfico está actualizado.
    chart.Measure(new Size(chart.Width, chart.Height));
    chart.Arrange(new Rect(0, 0, chart.Width, chart.Height));
    var renderTargetBitmap = new RenderTargetBitmap(
        (int)chart.ActualWidth,
        (int)chart.ActualHeight,
        96, //  valor dpiX
        96, //  Valor dpiY
        PixelFormats.Pbgra32); //  Formato de píxeles
    renderTargetBitmap.Render(chart); //  Renderizar el gráfico en el mapa de bits
    var encoder = new PngBitmapEncoder();
    encoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
    //  Definir la ruta donde se guardará el gráfico
    string path = "chart.png";
    using (var stream = File.Create(path))
    {
        encoder.Save(stream);
    }
    MessageBox.Show($"Chart saved as {path}");
}
private void GenerateChartButton_Click(object sender, RoutedEventArgs e)
{
    CreateAndSaveChartImage();
}
public void CreateAndSaveChartImage()
{
    var seriesCollection = new SeriesCollection
{
    new LineSeries
    {
        Values = new ChartValues<double> { 4, 6, 5, 2, 7 },
        Title = "Sample Series"
        //  Asegúrese de configurar las propiedades de las series, como el color, la geometría de los puntos, etc.
    }
};
    var chart = new CartesianChart
    {
        Series = seriesCollection,
        Width = 400,
        Height = 300,
        Background = Brushes.White
    };
    //  Añadir gráfico a la interfaz de usuario
    ChartContainer.Child = chart;
    chart.Update(true, true); //  Forzar el redibujado del gráfico
    SaveChartToImage(chart);
}
private void SaveChartToImage(CartesianChart chart)
{
    //  Asegúrese de que el diseño del gráfico está actualizado.
    chart.Measure(new Size(chart.Width, chart.Height));
    chart.Arrange(new Rect(0, 0, chart.Width, chart.Height));
    var renderTargetBitmap = new RenderTargetBitmap(
        (int)chart.ActualWidth,
        (int)chart.ActualHeight,
        96, //  valor dpiX
        96, //  Valor dpiY
        PixelFormats.Pbgra32); //  Formato de píxeles
    renderTargetBitmap.Render(chart); //  Renderizar el gráfico en el mapa de bits
    var encoder = new PngBitmapEncoder();
    encoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
    //  Definir la ruta donde se guardará el gráfico
    string path = "chart.png";
    using (var stream = File.Create(path))
    {
        encoder.Save(stream);
    }
    MessageBox.Show($"Chart saved as {path}");
}
Imports System

Private Sub GenerateChartButton_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
	CreateAndSaveChartImage()
End Sub
Public Sub CreateAndSaveChartImage()
	Dim seriesCollection As New SeriesCollection
		From {
			New LineSeries With {
				.Values = New ChartValues(Of Double) From {4, 6, 5, 2, 7},
				.Title = "Sample Series"
			}
		}
	Dim chart = New CartesianChart With {
		.Series = seriesCollection,
		.Width = 400,
		.Height = 300,
		.Background = Brushes.White
	}
	'  Añadir gráfico a la interfaz de usuario
	ChartContainer.Child = chart
	chart.Update(True, True) '  Forzar el redibujado del gráfico
	SaveChartToImage(chart)
End Sub
Private Sub SaveChartToImage(ByVal chart As CartesianChart)
	'  Asegúrese de que el diseño del gráfico está actualizado.
	chart.Measure(New Size(chart.Width, chart.Height))
	chart.Arrange(New Rect(0, 0, chart.Width, chart.Height))
	Dim renderTargetBitmap As New RenderTargetBitmap(CInt(Math.Truncate(chart.ActualWidth)), CInt(Math.Truncate(chart.ActualHeight)), 96, 96, PixelFormats.Pbgra32) '  Formato de píxeles
	renderTargetBitmap.Render(chart) '  Renderizar el gráfico en el mapa de bits
	Dim encoder = New PngBitmapEncoder()
	encoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap))
	'  Definir la ruta donde se guardará el gráfico
	Dim path As String = "chart.png"
	Using stream = File.Create(path)
		encoder.Save(stream)
	End Using
	MessageBox.Show($"Chart saved as {path}")
End Sub
VB   C#

Livecharts C# (Cómo funciona para desarrolladores): Figura 3

Paso 2: Crear una plantilla HTML e insertar el gráfico

Ahora, prepararemos nuestro contenido HTML, incrustando el gráfico que acabamos de guardar como imagen.

string htmlContent = @"
<html>
<body>
    <h1>Chart Report</h1>
    <img src='chart.png' alt='Chart'>
    <p>This is a report generated by combining LiveCharts and IronPDF.</p>
</body>
</html>";
string htmlContent = @"
<html>
<body>
    <h1>Chart Report</h1>
    <img src='chart.png' alt='Chart'>
    <p>This is a report generated by combining LiveCharts and IronPDF.</p>
</body>
</html>";
Dim htmlContent As String = "
<html>
<body>
    <h1>Chart Report</h1>
    <img src='chart.png' alt='Chart'>
    <p>This is a report generated by combining LiveCharts and IronPDF.</p>
</body>
</html>"
VB   C#

Paso 3: Convertir HTML a PDF con IronPDF

Por último, utilizaremos IronPDF para convertir nuestro contenido HTML, incluida la imagen del gráfico incrustada, en un documento PDF.

using IronPdf;
public void CreatePdfReport(string htmlContent)
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(htmlContent);
    pdf.SaveAs("Report.pdf");
}
using IronPdf;
public void CreatePdfReport(string htmlContent)
{
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(htmlContent);
    pdf.SaveAs("Report.pdf");
}
Imports IronPdf
Public Sub CreatePdfReport(ByVal htmlContent As String)
	Dim renderer = New ChromePdfRenderer()
	Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
	pdf.SaveAs("Report.pdf")
End Sub
VB   C#

Asegúrese de sustituir "chart.png " en la cadena htmlContent por la ruta correcta a la imagen de su gráfico si no está en el mismo directorio que el ejecutable de su aplicación.

Este ejemplo cubre un escenario básico para ilustrar el proceso. Dependiendo de sus necesidades específicas, es posible que tenga que ajustar el código, especialmente en lo que se refiere a cómo manejar y fuente de imágenes para sus gráficos.

Livecharts C# (Cómo funciona para desarrolladores): Figura 4

Técnicas y consejos avanzados

Para mejorar aún más la integración:

  • Optimizar el rendimiento: Para grandes conjuntos de datos o gráficos complejos, considere la posibilidad de optimizar el rendimiento tanto de LiveCharts como de IronPDF para garantizar tiempos de carga rápidos y un funcionamiento sin problemas.
  • PDF interactivos: Aunque los PDF son estáticos, añadir hipervínculos o marcadores puede mejorar la navegación y facilitar el uso de los informes.
  • Estilo personalizado: Utilice CSS dentro de sus plantillas HTML para asegurarse de que los informes coinciden con su marca corporativa o directrices de diseño.

Conclusión

Livecharts C# (Cómo funciona para desarrolladores): Figura 5

En conclusión, la integración de LiveCharts con IronPDF ofrece una potente combinación para los desarrolladores .NET que deseen crear gráficos dinámicos y visualmente atractivos e incorporarlos a informes PDF de estilo profesional. Esta sinergia no sólo mejora la presentación de los datos, sino que amplía la utilidad de las aplicaciones al facilitar la generación de informes estáticos a partir de conjuntos de datos dinámicos.

La capacidad de IronPDF de convertir HTML a PDF, con total compatibilidad con CSS3, JavaScript y HTML5, garantiza que sus gráficos pasen sin problemas de la pantalla a la página impresa. Para quienes estén interesados en explorar esta funcionalidad, IronPDF ofrece un prueba gratuita a partir de 749 dólares, proporcionando una solución rentable para la generación de informes de alta calidad en aplicaciones .NET.

< ANTERIOR
Masstransit C# (Cómo funciona para desarrolladores)
SIGUIENTE >
MS Graph .NET (Cómo funciona para desarrolladores)

¿Listo para empezar? Versión: 2024.6 recién publicada

Comenzar prueba gratuita Descargas totales: 9,541,998
Ver licencias >