Exemple de Microsoft.Extensions.Caching.Memory (avec PDF) en C#

Pour construire des applications réactives et efficaces, des méthodes d'optimisation sont souvent nécessaires pour les applications .NET. La mise en cache est une approche puissante qui consiste à stocker temporairement le matériel fréquemment demandé dans un cache distribué afin de faciliter une récupération plus rapide. La réduction du temps de traitement et de la charge du serveur grâce à cette stratégie peut entraîner une augmentation significative des performances de l'application. En outre, des compteurs de performance peuvent être mis en œuvre pour surveiller et améliorer le système de mise en cache.

Mise en cache est une stratégie d'optimisation efficace dans ce contexte. Microsoft.Extensions.Caching.Memory fournit une solution efficace de mise en cache d'objets en mémoire pour les applications .NET. Vos applications centrées sur le PDF fonctionneront et répondront beaucoup plus rapidement si vous utilisez stratégiquement le cache MemoryCache avec IronPDF.

Nous explorons comment intégrer efficacement les exemples C# Microsoft.Extensions.Caching.Memory avec IronPDF. Dans cet article, nous examinerons les avantages de la mise en cache en ce qui concerne laIronPDF Conversion de HTML en PDF et propose des conseils de mise en œuvre utiles, ainsi qu'une marche à suivre détaillée pour configurer la mise en cache dans votre programme IronPDF. Au final, vous disposerez des compétences et des ressources nécessaires pour développer des applications PDF efficaces et intuitives.

Microsoft.Extensions.Caching.Memory : La base de la mise en cache dans .NET

La mise en cache est une méthode utilisée dans de nombreuses applications .NET très performantes, qui permet de stocker en mémoire les données fréquemment consultées afin de les retrouver rapidement. Microsoft.Extensions est l'une des nombreuses options de mise en cache accessibles. Caching.Memory est une option particulièrement forte et adaptable. Cette bibliothèque est un composant de l'espace de noms plus large Microsoft.Extensions.Caching et offre une approche simple mais efficace de la mise en cache en mémoire.

Types de clés dans "Microsoft.Extensions.Caching.Memory" (en anglais)

IMemoryCache

• La capacité fondamentale d'utilisation du cache en mémoire est représentée par cette interface. Il permet de gérer les entrées mises en cache, de les ajouter, de les récupérer et de les supprimer.
• Considérez-le comme le principal point d'entrée de vos processus de mise en cache.

CacheMémoire

• L'implémentation réelle de IMemoryCache se trouve dans cette classe. Il offre une administration et un stockage réel en mémoire pour les éléments mis en cache.
• L'injection de dépendance est généralement utilisée dans les applications ASP.NET Core pour récupérer une instance de MemoryCache.

MemoryCacheEntryOptions (options de mémoire)

Cette classe permet de spécifier des paramètres de configuration pour des éléments de cache spécifiques. Ces paramètres régissent des éléments tels que

• Expiration : Vous pouvez configurer des fenêtres d'expiration glissantes(où l'entrée expire si elle n'est pas consultée dans un certain laps de temps) ou des délais d'expiration absolus(où l'inscription expire automatiquement).
• Priorité : Lorsque le cache se remplit, cette priorité détermine s'il convient d'expulser des éléments. Les entrées prioritaires ont moins de chances d'être supprimées.
• Rappel post-éviction : Cela vous permet d'affiner la logique de traitement des données lorsqu'elles ont expiré. Il est particulièrement utile dans les scénarios où des données critiques doivent être rafraîchies, dans la gestion des ressources et dans la journalisation.

CacheEntry

• Dans le cache, ce type désigne une seule entrée. Il propose des méthodes et des attributs pour récupérer les détails de la taille, les paramètres d'expiration et les valeurs mises en cache.
• En substance, il contient toutes les informations relatives à un élément particulier des données conservées dans le cache.

ICacheEntry (en anglais)

• Cette interface décrit les activités de base qui peuvent être effectuées sur un élément de cache, bien qu'elle ne soit pas nécessaire pour les opérations de base de la mise en cache. Il contient des instructions sur la manière de récupérer la valeur et les détails de l'expiration. Ceci est plus fréquent dans les scénarios où vous devez récupérer la clé de la chaîne de caractères.
• Cette interface est implémentée par la classe CacheEntry, qui offre une implémentation pratique de ces fonctionnalités.

Installer et configurer Microsoft.Extensions.Caching.Memory

configuration Microsoft.Extensions.Caching. Lors du démarrage de l'application, la mémoire est utilisée pour configurer le service de cache à l'intérieur de la collection de services de l'application ASP.NET Core. Une application ASP.NET Core pour laquelle le paramètre Microsoft.Extensions.Caching.Memory a été configuré est illustrée ci-dessous :

Installer le paquetage NuGet requis

Tout d'abord, assurez-vous que Microsoft.Extensions.Caching.Memory est installé pour votre projet. En utilisant la console NuGet Package Manager, vous pouvez l'installer avec la commande suivante :

Install-Package Microsoft.Extensions.Caching.Memory

Nous pouvons également utiliser le gestionnaire de paquets NuGet pour installer le paquet :

Configuration des services dans Startup.cs

Naviguez jusqu'à la méthode ConfigureServices dans votre application ASP.NET Core en ouvrant le fichier Startup.cs. Pour configurer le service de cache mémoire, ajoutez le code suivant :

using Microsoft.Extensions.Caching.Memory;
public void ConfigureServices(IServiceCollection services)
{
    // Add memory cache service
    services.AddMemoryCache();
    // Other service configurations...
}

using Microsoft.Extensions.Caching.Memory;
public void ConfigureServices(IServiceCollection services)
{
    // Add memory cache service
    services.AddMemoryCache();
    // Other service configurations...
}

Imports Microsoft.Extensions.Caching.Memory
Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Add memory cache service
	services.AddMemoryCache()
	' Other service configurations...
End Sub

L'objet de service de cache mémoire est ajouté à la collection de services de l'application et configuré par ce code. Le service de cache mémoire est enregistré en utilisant ses configurations par défaut via la fonction AddMemoryCache.

Injecter IMemoryCache

Une fois le magasin de cache mis en place, toute classe ou composant nécessitant une mise en cache peut se voir injecter l'interface IMemoryCache. Dans un contrôleur ou une classe de service, par exemple :

public class MyService
{
    private readonly IMemoryCache _cache;
    public MyService(IMemoryCache cache)
    {
        _cache = cache;
    }
    // Use _cache to perform caching operations...
}

public class MyService
{
    private readonly IMemoryCache _cache;
    public MyService(IMemoryCache cache)
    {
        _cache = cache;
    }
    // Use _cache to perform caching operations...
}

Public Class MyService
	Private ReadOnly _cache As IMemoryCache
	Public Sub New(ByVal cache As IMemoryCache)
		_cache = cache
	End Sub
	' Use _cache to perform caching operations...
End Class

Les méthodes de mise en cache et d'extraction des données de la mémoire sont fournies par l'interface IMemoryCache.

Configuration des options de cache

En définissant les paramètres du cache, vous pouvez modifier le comportement du cache mémoire. Il s'agit de configurer un ensemble de paramètres, notamment des restrictions de taille, des tactiques d'éviction des entrées du cache et des règles d'expiration des valeurs du cache. Ceci est une illustration de la manière de définir les options de cache :

public void ConfigureServices(IServiceCollection services)
{
    // Configure cache options
    services.AddMemoryCache(options =>
    {
        options.SizeLimit = 1024; // Set the maximum size limit for the cache
        options.CompactionPercentage = 0.75; // Set the percentage of memory to free up when the cache size exceeds the limit
        options.ExpirationScanFrequency = TimeSpan.FromMinutes(5); // Set how often the cache should scan for expired items
    });
    // Other service configurations...
}

public void ConfigureServices(IServiceCollection services)
{
    // Configure cache options
    services.AddMemoryCache(options =>
    {
        options.SizeLimit = 1024; // Set the maximum size limit for the cache
        options.CompactionPercentage = 0.75; // Set the percentage of memory to free up when the cache size exceeds the limit
        options.ExpirationScanFrequency = TimeSpan.FromMinutes(5); // Set how often the cache should scan for expired items
    });
    // Other service configurations...
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure cache options
	services.AddMemoryCache(Sub(options)
		options.SizeLimit = 1024 ' Set the maximum size limit for the cache
		options.CompactionPercentage = 0.75 ' Set the percentage of memory to free up when the cache size exceeds the limit
		options.ExpirationScanFrequency = TimeSpan.FromMinutes(5) ' Set how often the cache should scan for expired items
	End Sub)
	' Other service configurations...
End Sub

Modifiez les paramètres en fonction des spécifications de votre application.

Ces instructions vous aideront à configurer Microsoft.Extensions. Dans votre application ASP.NET Core, utilisez la fonction Caching.Memory. Les applications peuvent donc fonctionner plus rapidement et plus efficacement en stockant et en récupérant les données fréquemment consultées dans la mémoire cache.

Pour commencer

Qu'est-ce qu'IronPDF ?

Grâce à la célèbre bibliothèque IronPDF for NET, les programmeurs peuvent générer, modifier et afficher des documents PDF dans des applications .NET. La création de PDF à partir de contenu HTML, de photos ou de données brutes n'est qu'une des nombreuses fonctions qu'il offre pour travailler avec des PDF. D'autres fonctionnalités permettent d'ajouter du texte, des images et des formes à des documents PDF préexistants, de convertir des pages HTML en PDF et d'extraire du texte et des images de PDF.

Voici quelques caractéristiques d'IronPDF :

• Création de PDF à partir de HTML, de PNG et de données non traitées.
• Extraction d'images et de texte à partir de PDF.
• Ajout d'en-têtes, de pieds de page et de filigranes au format PDF.
• Documents PDF avec protection par mot de passe et cryptage.
• Remplissage de formulaires et possibilité de signature numérique.

Installer le paquet NuGet

Dans votre projet, assurez-vous que le paquetage IronPDF est installé. La console NuGet Package Manager peut être utilisée pour l'installer :

Install-Package IronPdf

Pour accéder à la fonction ConfigureServices, ouvrez le fichier Startup.cs dans votre application ASP.NET Core. Pour configurer IronPDF, ajoutez le code suivant.

using IronPdf;
public void ConfigureServices(IServiceCollection services)
{
    // Configure IronPDF
    services.AddSingleton<HtmlToPdf>();
    // Other service configurations...
}

using IronPdf;
public void ConfigureServices(IServiceCollection services)
{
    // Configure IronPDF
    services.AddSingleton<HtmlToPdf>();
    // Other service configurations...
}

Imports IronPdf
Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure IronPDF
	services.AddSingleton(Of HtmlToPdf)()
	' Other service configurations...
End Sub

En configurant le service HtmlToPdf d'IronPDF comme un singleton, ce code s'assure que l'application ne crée et n'utilise qu'une seule instance de HtmlToPdf.

Utilisation de Microsoft.Extensions.Caching.Memory avec IronPDF

Dans les applications .NET, Microsoft.Extensions.Caching.Memory offre un moyen pratique de stocker les données fréquemment demandées pour les récupérer plus rapidement.

Ce code source et cet extrait illustrent son utilisation fondamentale :

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System.Net;
using System.Net.Http.Headers;
namespace DemoWebApplication.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class DemoController : ControllerBase
    {
        private readonly IMemoryCache _cache;
        private readonly HtmlToPdf _htmlToPdf;
        private readonly ILogger<DemoController > _logger;
        public DemoController(ILogger<DemoController > logger, IMemoryCache cache, HtmlToPdf htmlToPdf)
        {
            _logger = logger;
            _cache = cache;
            _htmlToPdf = htmlToPdf;
        }
        [HttpGet]
        public FileContentResult Generate()
        {
            string fileName = "Sample.pdf";
            var stream = GeneratePdf("Hello IronPDF");
            return new FileContentResult(stream, "application/octet-stream")
            {
                FileDownloadName = fileName
            };
        }
        private byte[] GeneratePdf(string htmlContent)
        {
        // object key
            string cacheKey = "GeneratedPdf";
            if (!_cache.TryGetValue(cacheKey, out byte[] pdfBytes))
            {
                // PDF not found in cache, generate it
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);
                pdfBytes = pdfDocument.BinaryData;
                // Cache the generated PDF with a sliding expiration of 1 hour
                _cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1));
            }
            return pdfBytes;
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System.Net;
using System.Net.Http.Headers;
namespace DemoWebApplication.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class DemoController : ControllerBase
    {
        private readonly IMemoryCache _cache;
        private readonly HtmlToPdf _htmlToPdf;
        private readonly ILogger<DemoController > _logger;
        public DemoController(ILogger<DemoController > logger, IMemoryCache cache, HtmlToPdf htmlToPdf)
        {
            _logger = logger;
            _cache = cache;
            _htmlToPdf = htmlToPdf;
        }
        [HttpGet]
        public FileContentResult Generate()
        {
            string fileName = "Sample.pdf";
            var stream = GeneratePdf("Hello IronPDF");
            return new FileContentResult(stream, "application/octet-stream")
            {
                FileDownloadName = fileName
            };
        }
        private byte[] GeneratePdf(string htmlContent)
        {
        // object key
            string cacheKey = "GeneratedPdf";
            if (!_cache.TryGetValue(cacheKey, out byte[] pdfBytes))
            {
                // PDF not found in cache, generate it
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);
                pdfBytes = pdfDocument.BinaryData;
                // Cache the generated PDF with a sliding expiration of 1 hour
                _cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1));
            }
            return pdfBytes;
        }
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Caching.Memory
Imports System.Net
Imports System.Net.Http.Headers
Namespace DemoWebApplication.Controllers
	<ApiController>
	<Route("[controller]")>
	Public Class DemoController
		Inherits ControllerBase

		Private ReadOnly _cache As IMemoryCache
		Private ReadOnly _htmlToPdf As HtmlToPdf
		Private ReadOnly _logger As ILogger(Of DemoController )
		Public Sub New(ByVal logger As ILogger(Of DemoController ), ByVal cache As IMemoryCache, ByVal htmlToPdf As HtmlToPdf)
			_logger = logger
			_cache = cache
			_htmlToPdf = htmlToPdf
		End Sub
		<HttpGet>
		Public Function Generate() As FileContentResult
			Dim fileName As String = "Sample.pdf"
			Dim stream = GeneratePdf("Hello IronPDF")
			Return New FileContentResult(stream, "application/octet-stream") With {.FileDownloadName = fileName}
		End Function
		Private Function GeneratePdf(ByVal htmlContent As String) As Byte()
		' object key
			Dim cacheKey As String = "GeneratedPdf"
			Dim pdfBytes() As Byte
			If Not _cache.TryGetValue(cacheKey, pdfBytes) Then
				' PDF not found in cache, generate it
				Dim pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent)
				pdfBytes = pdfDocument.BinaryData
				' Cache the generated PDF with a sliding expiration of 1 hour
				_cache.Set(cacheKey, pdfBytes, TimeSpan.FromHours(1))
			End If
			Return pdfBytes
		End Function
	End Class
End Namespace

Nous importons les espaces de noms nécessaires pour travailler avec Microsoft et ASP.NET Microsoft.Extensions.Caching.Memory. Nous créons le contrôleur DemoController, qui est dérivé de ControllerBase. Ce contrôleur répondra aux requêtes envoyées par HTTP. Une instance de IMemoryCache est injectée dans le constructeur du contrôleur.

Pour contrôler la durée de vie des services, notamment le cache mémoire, ASP.NET Core propose l'injection de dépendances. Avec la[HttpGet] appliquée, la méthode Generate est marquée pour traiter les requêtes HTTP GET vers le magasin à partir de la route désignée(/Démo). Nous essayons d'obtenir les données de prévisions météorologiques du cache dans la fonction Generate en utilisant la clé de cache donnée. Si les données ASP ne peuvent pas être utilisées et se trouvent dans le cache, nous utilisons la fonction Generate pour créer de nouvelles données météorologiques.

Dans un scénario avec plusieurs serveurs d'applications, assurez-vous de configurer la mise en cache distribuée pour une gestion cohérente du cache sur tous les serveurs.

Pour utiliser Microsoft.Extensions.Caching.Memory, reportez-vous à la documentation et aux exemples de code fournis pour mettre en cache des données et améliorer les performances dans les applications ASP.NET Core. En pratique, vous pouvez adapter les politiques d'expiration, les clés de cache et le comportement de la mise en cache aux besoins de votre application. La mise en cache des données dont la génération est coûteuse ou qui sont souvent consultées par plusieurs threads peut améliorer l'expérience globale de l'utilisateur et réduire considérablement les temps de réponse.

Conclusion

Tout bien considéré, Microsoft.Extensions.Caching.Memory peut être utilisé pour augmenter l'évolutivité et les performances des applications .NET, en particulier celles qui sont basées sur le framework ASP.NET Core. Les développeurs peuvent améliorer l'expérience des utilisateurs, minimiser la latence et optimiser l'accès aux données en utilisant la mise en cache en mémoire. La bibliothèque fournit une API flexible et conviviale permettant de développer des stratégies de mise en cache adaptées aux exigences particulières des applications, qu'il s'agisse de mettre en cache des données de référence, des résultats de requêtes ou des valeurs calculées. Vous pouvez obtenir des gains de vitesse notables et améliorer la réactivité de vos applications en adoptant les meilleures pratiques de mise en cache et en ajoutant Microsoft.Extensions.Caching.Memory à vos applications .NET.

En utilisant les fonctionnalités de Microsoft.Extensions', avec l'aide d'IronPDF pour la création dynamique de PDF et de Caching.Memory pour une mise en cache efficace des données, les développeurs .NET peuvent considérablement améliorer la vitesse de leurs applications. Cette puissante combinaison permet aux développeurs de concevoir facilement des applications performantes, évolutives et réactives en réduisant la charge du serveur, en améliorant l'expérience de l'utilisateur et en éliminant les frais généraux de traitement.

IronPDF peut être acheté à un prix raisonnable, et l'acquisition du package inclut une licence à vie. Le paquet offre une valeur exceptionnelle puisqu'il commence à $749, un tarif unique pour plusieurs systèmes. Pour les utilisateurs disposant d'une licence, il offre une assistance technique en ligne 24 heures sur 24. Pour plus d'informations sur l'accusation, veuillez consulter le site web de la Commission européennePage de licence IronPDF. Visiter ce sitepage sur Iron Software pour en savoir plus sur les produits fabriqués par Iron Software.