Qu'est-ce que AppMetrics C# et comment cela profite-t-il aux développeurs ?

AppMetrics C# est un outil conçu pour la surveillance des applications et l'analyse des performances, permettant aux développeurs de suivre et récupérer efficacement diverses métriques d'application dans .NET Core et .NET Framework.

Comment AppMetrics peut-il être intégré dans un projet .NET ?

Vous pouvez intégrer AppMetrics dans votre projet .NET en utilisant le Package Manager NuGet avec la commande : Install-Package App.Metrics.AspNetCore .

Quel est le rôle de IronPDF dans la génération de rapports à partir des données AppMetrics ?

IronPDF peut être utilisé pour générer des rapports PDF complets à partir des données AppMetrics en convertissant les données de métriques formatées en HTML en PDF de haute qualité, idéal pour les évaluations de performance et les présentations.

Comment des métriques personnalisées peuvent-elles être suivies en utilisant AppMetrics ?

AppMetrics vous permet de définir et de suivre des métriques personnalisées, telles que l'activité des utilisateurs ou le temps de transactions spécifiques, permettant une analyse des performances détaillée adaptée aux besoins de votre application.

Quelles options sont disponibles pour visualiser les données AppMetrics ?

AppMetrics prend en charge le reporting vers divers tableaux de bord, comme InfluxDB, permettant aux développeurs de visualiser et de surveiller efficacement les données de métriques.

Comment les développeurs peuvent-ils optimiser les performances des applications en utilisant AppMetrics ?

Les développeurs peuvent optimiser les performances en utilisant AppMetrics pour surveiller l'utilisation de la mémoire et gérer les métriques programmées, assurant une gestion efficace des ressources et une réactivité de l'application.

Quels sont les avantages de générer des rapports PDF avec IronPDF ?

Utiliser IronPDF pour générer des rapports PDF à partir des données AppMetrics offre l'avantage de créer des documents professionnels et faciles à lire, améliorant la communication avec les parties prenantes.

Existe-t-il un essai gratuit pour IronPDF ?

Oui, IronPDF propose un essai gratuit, permettant aux développeurs d'explorer ses capacités de génération de PDF avant de s'engager dans un achat.

What are the advantages of using AppMetrics in cross-platform environments?

AppMetrics is advantageous in cross-platform environments as it ensures consistent performance monitoring across diverse setups, supporting both .NET Core and .NET Framework applications.

Is it possible to visualize AppMetrics data on a dashboard?

Yes, AppMetrics supports reporting metrics to various dashboards, such as InfluxDB, to visualize and monitor the data effectively, thereby enhancing the analytical insights derived from application metrics.

La Bibliothèque PDF C#

Explore IronPDF Essai gratuit

HTML en PDF

Online Demo Voir tous les exemples de code %s

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

MISES À JOUR POUR LES DÉVELOPPEURS

Appmetrics C# (Comment ça fonctionne pour les développeurs) | IronPDF

Jacob Mellor

Updated: 21 avril 2026

AppMetrics C# est un outil puissant conçu pour rationaliser la surveillance des applications et l'analyse des performances. Avec les abstractions AppMetrics, il simplifie la complexité impliquée dans le suivi de divers aspects de votre application. Que vous utilisiez .NET Core ou le .NET Framework, cette bibliothèque .NET vous permet d'enregistrer efficacement les types de métriques. Vous pouvez récupérer des métriques et utiliser les types de métriques pris en charge par AppMetrics pour obtenir des informations complètes.

La bibliothèque .NET prend en charge la récupération des métriques et vous permet de les vider à un intervalle spécifié, garantissant une collecte de données en temps opportun. Elle offre également une méthode d'extension, fournissant des points d'extensibilité pour une flexibilité accrue. En tant que solution multiplateforme, AppMetrics est adapté à divers environnements et assure une surveillance cohérente des performances.

IronPDF: Bibliothèque PDF avancée pour les développeurs C# est une autre bibliothèque essentielle pour les développeurs C#, notamment lors de la manipulation de documents PDF. Elle permet la création, l'édition et l'extraction de fichiers PDF directement dans les applications .NET Core. Cela peut être particulièrement utile dans des scénarios où vous devez générer des rapports, des factures ou tout autre document au format PDF depuis votre application.

Démarrer avec AppMetrics

Pour intégrer AppMetrics multiplateforme dans votre projet .NET, vous commencez par installer la bibliothèque AppMetrics. Vous pouvez le faire en utilisant les packages NuGet, le gestionnaire de packages pour .NET. Dans votre projet, exécutez la commande suivante dans la console du gestionnaire de packages NuGet :

PM > Install-Package App.Metrics.AspNetCore

Install-Package App.Metrics.AspNetCore

Appmetrics C# (Comment cela fonctionne pour les développeurs) : Figure 1 - AppMetrics

Cette commande ajoute toutes les dépendances nécessaires à votre projet, vous permettant de commencer à configurer AppMetrics.

Un exemple de code de base : surveillance des requêtes HTTP

Voici comment vous pouvez configurer une surveillance de base pour les requêtes HTTP dans votre application .NET à l'aide d'AppMetrics. Tout d'abord, construisez les métriques dans votre fichier Startup.cs. Ajoutez le code suivant à la méthode ConfigureServices :

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetrics(); // Add basic metrics services
    services.AddMetricsTrackingMiddleware(); // Enable middleware for tracking
    services.AddMetricsEndpoints(); // Add endpoints for metrics exposure
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetrics(); // Add basic metrics services
    services.AddMetricsTrackingMiddleware(); // Enable middleware for tracking
    services.AddMetricsEndpoints(); // Add endpoints for metrics exposure
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddMetrics() ' Add basic metrics services
	services.AddMetricsTrackingMiddleware() ' Enable middleware for tracking
	services.AddMetricsEndpoints() ' Add endpoints for metrics exposure
End Sub

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddMetrics() ' Add basic metrics services
	services.AddMetricsTrackingMiddleware() ' Enable middleware for tracking
	services.AddMetricsEndpoints() ' Add endpoints for metrics exposure
End Sub

Ensuite, dans la méthode Configure du même fichier, assurez-vous d'ajouter le middleware AppMetrics pour gérer la surveillance :

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMetricsAllMiddleware(); // Register the middleware to capture all metrics
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMetricsAllMiddleware(); // Register the middleware to capture all metrics
}

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	app.UseMetricsAllMiddleware() ' Register the middleware to capture all metrics
End Sub

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	app.UseMetricsAllMiddleware() ' Register the middleware to capture all metrics
End Sub

Cette configuration commence automatiquement à capturer des métriques sur les requêtes HTTP entrantes vers votre application, telles que le nombre de requêtes, la durée des requêtes et les taux d'erreur.

Implémenter les fonctionnalités d'AppMetrics

Enregistrement de métriques personnalisées

Pour créer et enregistrer des métriques personnalisées ou mesurer des éléments dans votre application, AppMetrics offre un moyen flexible de définir ce qui a besoin d'être suivi. Voici un exemple d'enregistrement d'un compteur simple pour suivre les connexions utilisateur :

public class LoginTracker
{
    private readonly IMetrics _metrics;

    public LoginTracker(IMetrics metrics)
    {
        _metrics = metrics;
    }

    public void TrackLogin(string userId)
    {
        // Increment login counter for the specified user ID
        _metrics.Measure.Counter.Increment(MetricsRegistry.Logins, new MetricTags("UserId", userId));
    }
}

public class LoginTracker
{
    private readonly IMetrics _metrics;

    public LoginTracker(IMetrics metrics)
    {
        _metrics = metrics;
    }

    public void TrackLogin(string userId)
    {
        // Increment login counter for the specified user ID
        _metrics.Measure.Counter.Increment(MetricsRegistry.Logins, new MetricTags("UserId", userId));
    }
}

Public Class LoginTracker
	Private ReadOnly _metrics As IMetrics

	Public Sub New(ByVal metrics As IMetrics)
		_metrics = metrics
	End Sub

	Public Sub TrackLogin(ByVal userId As String)
		' Increment login counter for the specified user ID
		_metrics.Measure.Counter.Increment(MetricsRegistry.Logins, New MetricTags("UserId", userId))
	End Sub
End Class

Public Class LoginTracker
	Private ReadOnly _metrics As IMetrics

	Public Sub New(ByVal metrics As IMetrics)
		_metrics = metrics
	End Sub

	Public Sub TrackLogin(ByVal userId As String)
		' Increment login counter for the specified user ID
		_metrics.Measure.Counter.Increment(MetricsRegistry.Logins, New MetricTags("UserId", userId))
	End Sub
End Class

Dans ce code, chaque fois que TrackLogin est appelé, le compteur de connexions augmente pour l'ID utilisateur spécifié.

Mesurer les performances de l'application

AppMetrics peut également être utilisé pour mesurer la performance de l'application. Par exemple, vous pouvez suivre la durée d'une méthode spécifique à l'aide de minuteries :

public void ProcessData()
{
    // Measure time taken by the database query process
    using (_metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer))
    {
        // Code to execute a database query goes here
    }
}

public void ProcessData()
{
    // Measure time taken by the database query process
    using (_metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer))
    {
        // Code to execute a database query goes here
    }
}

Public Sub ProcessData()
	' Measure time taken by the database query process
	Using _metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer)
		' Code to execute a database query goes here
	End Using
End Sub

Public Sub ProcessData()
	' Measure time taken by the database query process
	Using _metrics.Measure.Timer.Time(MetricsRegistry.DatabaseQueryTimer)
		' Code to execute a database query goes here
	End Using
End Sub

Cette minuterie enregistre le temps que met la méthode ProcessData à s'exécuter, fournissant des informations sur les performances des requêtes de base de données.

Rapport des métriques à un tableau de bord

Pour visualiser et surveiller vos différents types de métriques, AppMetrics peut rapporter les données à différents tableaux de bord. Voici comment vous pouvez configurer le rapport vers un tableau de bord InfluxDB :

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetricsReportingHostedService();
    services.AddMetrics(builder =>
    {
        builder.Report.ToInfluxDb(options =>
        {
            options.InfluxDb.BaseUri = new Uri("http://your-influxdb-server"); // Configure InfluxDB server URI
            options.InfluxDb.Database = "appmetricsdb"; // Specify the database name
            options.InfluxDb.UserName = "user"; // Set database username
            options.InfluxDb.Password = "password"; // Set database password
            options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30); // Set backoff period
            options.HttpPolicy.FailuresBeforeBackoff = 5; // Set failure count before backoff
            options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10); // Set HTTP timeout duration
            options.FlushInterval = TimeSpan.FromSeconds(5); // Set interval for reporting metrics
        });
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddMetricsReportingHostedService();
    services.AddMetrics(builder =>
    {
        builder.Report.ToInfluxDb(options =>
        {
            options.InfluxDb.BaseUri = new Uri("http://your-influxdb-server"); // Configure InfluxDB server URI
            options.InfluxDb.Database = "appmetricsdb"; // Specify the database name
            options.InfluxDb.UserName = "user"; // Set database username
            options.InfluxDb.Password = "password"; // Set database password
            options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30); // Set backoff period
            options.HttpPolicy.FailuresBeforeBackoff = 5; // Set failure count before backoff
            options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10); // Set HTTP timeout duration
            options.FlushInterval = TimeSpan.FromSeconds(5); // Set interval for reporting metrics
        });
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddMetricsReportingHostedService()
	services.AddMetrics(Sub(builder)
		builder.Report.ToInfluxDb(Sub(options)
			options.InfluxDb.BaseUri = New Uri("http://your-influxdb-server") ' Configure InfluxDB server URI
			options.InfluxDb.Database = "appmetricsdb" ' Specify the database name
			options.InfluxDb.UserName = "user" ' Set database username
			options.InfluxDb.Password = "password" ' Set database password
			options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30) ' Set backoff period
			options.HttpPolicy.FailuresBeforeBackoff = 5 ' Set failure count before backoff
			options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10) ' Set HTTP timeout duration
			options.FlushInterval = TimeSpan.FromSeconds(5) ' Set interval for reporting metrics
		End Sub)
	End Sub)
End Sub

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddMetricsReportingHostedService()
	services.AddMetrics(Sub(builder)
		builder.Report.ToInfluxDb(Sub(options)
			options.InfluxDb.BaseUri = New Uri("http://your-influxdb-server") ' Configure InfluxDB server URI
			options.InfluxDb.Database = "appmetricsdb" ' Specify the database name
			options.InfluxDb.UserName = "user" ' Set database username
			options.InfluxDb.Password = "password" ' Set database password
			options.HttpPolicy.BackoffPeriod = TimeSpan.FromSeconds(30) ' Set backoff period
			options.HttpPolicy.FailuresBeforeBackoff = 5 ' Set failure count before backoff
			options.HttpPolicy.Timeout = TimeSpan.FromSeconds(10) ' Set HTTP timeout duration
			options.FlushInterval = TimeSpan.FromSeconds(5) ' Set interval for reporting metrics
		End Sub)
	End Sub)
End Sub

Suivi de l'utilisation de la mémoire

La surveillance de l'utilisation de la mémoire système est cruciale pour l'optimisation des performances. Voici comment vous pouvez suivre la mémoire libre :

public void CheckSystemMemory()
{
    var freeMemory = GC.GetTotalMemory(false); // Get total free memory
    _metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory); // Set gauge to measure free memory
}

public void CheckSystemMemory()
{
    var freeMemory = GC.GetTotalMemory(false); // Get total free memory
    _metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory); // Set gauge to measure free memory
}

Public Sub CheckSystemMemory()
	Dim freeMemory = GC.GetTotalMemory(False) ' Get total free memory
	_metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory) ' Set gauge to measure free memory
End Sub

Public Sub CheckSystemMemory()
	Dim freeMemory = GC.GetTotalMemory(False) ' Get total free memory
	_metrics.Measure.Gauge.SetValue(MetricsRegistry.FreeMemory, freeMemory) ' Set gauge to measure free memory
End Sub

Ce jauge mesure la mémoire libre disponible pour votre application, vous aidant à comprendre les schémas de consommation de mémoire.

Gestion des métriques à intervalles spécifiés

AppMetrics peut être configuré pour gérer la collecte des métriques à des intervalles spécifiés. Cela permet de maintenir les performances sans enregistrer les données trop fréquemment :

public void ConfigureScheduledReporting(IApplicationBuilder app)
{
    var metrics = app.ApplicationServices.GetService<IMetricsRoot>(); // Retrieve the IMetricsRoot instance
    var scheduler = new AppMetricsTaskScheduler(
        TimeSpan.FromSeconds(60), // Set the interval for metrics collection
        async () =>
        {
            await Task.WhenAll(metrics.ReportRunner.RunAllAsync()); // Run all reports asynchronously
        });
    scheduler.Start(); // Start the scheduler
}

public void ConfigureScheduledReporting(IApplicationBuilder app)
{
    var metrics = app.ApplicationServices.GetService<IMetricsRoot>(); // Retrieve the IMetricsRoot instance
    var scheduler = new AppMetricsTaskScheduler(
        TimeSpan.FromSeconds(60), // Set the interval for metrics collection
        async () =>
        {
            await Task.WhenAll(metrics.ReportRunner.RunAllAsync()); // Run all reports asynchronously
        });
    scheduler.Start(); // Start the scheduler
}

Public Sub ConfigureScheduledReporting(ByVal app As IApplicationBuilder)
	Dim metrics = app.ApplicationServices.GetService(Of IMetricsRoot)() ' Retrieve the IMetricsRoot instance
	Dim scheduler = New AppMetricsTaskScheduler(TimeSpan.FromSeconds(60), Async Sub()
			Await Task.WhenAll(metrics.ReportRunner.RunAllAsync()) ' Run all reports asynchronously
	End Sub)
	scheduler.Start() ' Start the scheduler
End Sub

Public Sub ConfigureScheduledReporting(ByVal app As IApplicationBuilder)
	Dim metrics = app.ApplicationServices.GetService(Of IMetricsRoot)() ' Retrieve the IMetricsRoot instance
	Dim scheduler = New AppMetricsTaskScheduler(TimeSpan.FromSeconds(60), Async Sub()
			Await Task.WhenAll(metrics.ReportRunner.RunAllAsync()) ' Run all reports asynchronously
	End Sub)
	scheduler.Start() ' Start the scheduler
End Sub

Cette configuration définit les métriques à rapporter toutes les 60 secondes, assurant une surveillance cohérente des performances sans saturer le système avec un enregistrement de données continu.

Intégration d'AppMetrics avec IronPDF

Lors de l'utilisation de métriques et de la génération de PDF dans vos applications C#, combiner AppMetrics C# avec IronPDF peut être très bénéfique. Cette intégration vous permet de générer des rapports au format PDF directement à partir de vos données de métriques, ce qui est utile pour les revues de performances, les présentations clients ou même les audits internes.

Introduction à IronPDF

IronPDF est une bibliothèque complète qui permet aux développeurs de créer, lire et éditer des documents PDF à l'aide de C#. Ce qui distingue IronPDF, c'est sa capacité à convertir du HTML en PDF avec IronPDF, ce qui est particulièrement précieux pour la génération de rapports basés sur le web. Cette capacité garantit que les aspects visuels de vos rapports sont préservés, offrant un haut degré de fidélité du web à l'impression.

Use Case of Merging IronPDF with AppMetrics C#

Considérez un scénario où vous devez fournir des rapports mensuels de performance de votre application aux parties prenantes. Ces rapports incluent des métriques comme les temps de réponse, les taux d'erreurs, les sessions utilisateur et d'autres. Avec AppMetrics C# open-source, vous pouvez capturer ces métriques sans problème. En fusionnant cette fonctionnalité avec IronPDF, vous pouvez générer et distribuer automatiquement ces métriques dans un document PDF proprement formaté.

Exemple de code de cas d'utilisation

Voici un exemple complet de l'implémentation de cela. Cet exemple suppose que vous avez déjà configuré à la fois IronPDF et AppMetrics C# dans votre projet.

using App.Metrics;
using App.Metrics.Formatters.Prometheus;
using IronPdf;
public class MetricsToPdfConverter
{
    private readonly IMetricsRoot _metrics;

    public MetricsToPdfConverter(IMetricsRoot metrics)
    {
        _metrics = metrics;
    }

    public void GeneratePdfReport(string outputPath)
    {
        // Step 1: Capture the metrics snapshot
        var metricsData = _metrics.Snapshot.Get();
        var formatter = new MetricsPrometheusTextOutputFormatter();
        using var stream = new MemoryStream();
        formatter.WriteAsync(stream, metricsData).Wait();

        // Step 2: Convert the metrics snapshot to string format
        stream.Position = 0;
        var reader = new StreamReader(stream);
        var metricsText = reader.ReadToEnd();

        // Step 3: Use IronPDF to convert the metrics text to a PDF document
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" + metricsText + "</pre>");

        // Step 4: Save the PDF document
        pdf.SaveAs(outputPath);
    }
}

// Usage
var metrics = new MetricsBuilder().Build();
var pdfConverter = new MetricsToPdfConverter(metrics);
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf");

using App.Metrics;
using App.Metrics.Formatters.Prometheus;
using IronPdf;
public class MetricsToPdfConverter
{
    private readonly IMetricsRoot _metrics;

    public MetricsToPdfConverter(IMetricsRoot metrics)
    {
        _metrics = metrics;
    }

    public void GeneratePdfReport(string outputPath)
    {
        // Step 1: Capture the metrics snapshot
        var metricsData = _metrics.Snapshot.Get();
        var formatter = new MetricsPrometheusTextOutputFormatter();
        using var stream = new MemoryStream();
        formatter.WriteAsync(stream, metricsData).Wait();

        // Step 2: Convert the metrics snapshot to string format
        stream.Position = 0;
        var reader = new StreamReader(stream);
        var metricsText = reader.ReadToEnd();

        // Step 3: Use IronPDF to convert the metrics text to a PDF document
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" + metricsText + "</pre>");

        // Step 4: Save the PDF document
        pdf.SaveAs(outputPath);
    }
}

// Usage
var metrics = new MetricsBuilder().Build();
var pdfConverter = new MetricsToPdfConverter(metrics);
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf");

Imports App.Metrics
Imports App.Metrics.Formatters.Prometheus
Imports IronPdf
Public Class MetricsToPdfConverter
	Private ReadOnly _metrics As IMetricsRoot

	Public Sub New(ByVal metrics As IMetricsRoot)
		_metrics = metrics
	End Sub

	Public Sub GeneratePdfReport(ByVal outputPath As String)
		' Step 1: Capture the metrics snapshot
		Dim metricsData = _metrics.Snapshot.Get()
		Dim formatter = New MetricsPrometheusTextOutputFormatter()
		Dim stream = New MemoryStream()
		formatter.WriteAsync(stream, metricsData).Wait()

		' Step 2: Convert the metrics snapshot to string format
		stream.Position = 0
		Dim reader = New StreamReader(stream)
		Dim metricsText = reader.ReadToEnd()

		' Step 3: Use IronPDF to convert the metrics text to a PDF document
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" & metricsText & "</pre>")

		' Step 4: Save the PDF document
		pdf.SaveAs(outputPath)
	End Sub
End Class

' Usage
Private metrics = (New MetricsBuilder()).Build()
Private pdfConverter = New MetricsToPdfConverter(metrics)
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf")

Imports App.Metrics
Imports App.Metrics.Formatters.Prometheus
Imports IronPdf
Public Class MetricsToPdfConverter
	Private ReadOnly _metrics As IMetricsRoot

	Public Sub New(ByVal metrics As IMetricsRoot)
		_metrics = metrics
	End Sub

	Public Sub GeneratePdfReport(ByVal outputPath As String)
		' Step 1: Capture the metrics snapshot
		Dim metricsData = _metrics.Snapshot.Get()
		Dim formatter = New MetricsPrometheusTextOutputFormatter()
		Dim stream = New MemoryStream()
		formatter.WriteAsync(stream, metricsData).Wait()

		' Step 2: Convert the metrics snapshot to string format
		stream.Position = 0
		Dim reader = New StreamReader(stream)
		Dim metricsText = reader.ReadToEnd()

		' Step 3: Use IronPDF to convert the metrics text to a PDF document
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf("<h1> Metrics Report </h1> <pre>" & metricsText & "</pre>")

		' Step 4: Save the PDF document
		pdf.SaveAs(outputPath)
	End Sub
End Class

' Usage
Private metrics = (New MetricsBuilder()).Build()
Private pdfConverter = New MetricsToPdfConverter(metrics)
pdfConverter.GeneratePdfReport("MonthlyPerformanceReport.pdf")

Appmetrics C# (Comment cela fonctionne pour les développeurs) : Figure 2 - Sortie du rapport PDF

Cette intégration automatise non seulement le processus de génération de rapports, mais garantit également que les rapports sont facilement lisibles et professionnellement formatés, parfaits pour toute réunion avec les parties prenantes ou pour des fins d'archivage.

Conclusion

En résumé, combiner AppMetrics C# avec IronPDF dans vos projets .NET fournit une solution robuste pour surveiller les performances de l'application et générer des rapports PDF de haute qualité. Cette intégration vous permet de passer sans problème de la capture de données de performances détaillées avec AppMetrics à leur présentation dans un format clair et professionnel à l'aide d'IronPDF.

IronPDF est particulièrement avantageux pour les développeurs C# cherchant à manipuler des fichiers PDF au sein de leurs applications. Elle simplifie la création et la manipulation de documents PDF et offre une capacité unique à convertir directement du HTML en PDF. Si vous envisagez d'incorporer IronPDF dans vos projets, ils offrent un essai gratuit de IronPDF pour commencer, et les licences commencent à $999, offrant un moyen rentable d'améliorer vos capacités de gestion de documents.

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...