Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. exemple c# de Microsoft.extensions.caching.memory
.NET AIDE

Microsoft.Extensions.Caching.Memory Example (Avec PDF) en C#

Curtis Chau
Curtis Chau
Mis à jour:

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

La mise en cache est une stratégie d'optimisation puissante 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 les PDF fonctionneront et répondront beaucoup plus rapidement si vous utilisez stratégiquement le cache MemoryCache avec IronPDF.

Nous explorons comment intégrer des exemples C# de Microsoft.Extensions.Caching.Memory avec IronPDF de manière efficace. Dans cet article, nous discuterons des avantages de la mise en cache concernant le processus de conversion HTML en PDF d'IronPDF, passerons en revue quelques conseils de mise en œuvre utiles et offrirons une présentation détaillée de la configuration de la mise en cache dans votre programme IronPDF. Lorsque tout sera dit et fait, vous aurez les compétences et les ressources nécessaires pour développer des applications PDF efficaces et intuitives.

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

La mise en cache est une méthode utilisée dans de nombreuses applications .NET haute performance qui stocke les données fréquemment accédées en mémoire pour une récupération rapide. Microsoft.Extensions est l'une des nombreuses options de mise en cache accessibles. Caching.Memory est une option particulièrement solide et adaptable. Cette bibliothèque est un composant du plus large espace de noms Microsoft.Extensions.Caching offrant une approche de mise en cache en mémoire simple mais efficace.

Types clés au sein de "Microsoft.Extensions.Caching.Memory"

IMemoryCache

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

MemoryCache

  • La mise en œuvre 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épendances est généralement utilisée dans les applications ASP.NET Core pour récupérer une instance de MemoryCache.

MemoryCacheEntryOptions

Vous pouvez spécifier les paramètres de configuration pour des éléments de cache spécifiques avec cette classe. Ces paramètres régulent des choses comme :

  • Expiration : Vous pouvez configurer des fenêtres d'expiration glissantes (où l'entrée expire si elle n'est pas accédée dans un certain intervalle) ou des temps d'expiration absolus (où l'entrée expire automatiquement).
  • Priorité : Cela influence si l'on doit évincer des éléments lorsque le cache se remplit. Les entrées de priorité supérieure ont moins de chances d'être supprimées.
  • Rappel post-échéance : Cela vous permet de régler finement la logique de gestion des données lorsqu'elles ont expiré. C'est particulièrement utile là où des données critiques nécessitent une actualisation, une gestion des ressources et une journalisation.

CacheEntry

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

ICacheEntry

  • 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 mise en cache de base. Il contient des instructions sur la façon de récupérer les détails de la valeur et de l'expiration. C'est plus courant dans des scénarios où vous devez récupérer la clé de chaîne.
  • Cette interface est implémentée par la classe CacheEntry, qui offre une mise en œuvre pratique de ces fonctionnalités.

Installer et configurer Microsoft.Extensions.Caching.Memory

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. Ci-dessous se trouve une application ASP.NET Core avec Microsoft.Extensions.Caching.Memory configuré :

Installer le package NuGet requis

Tout d'abord, assurez-vous que Microsoft.Extensions.Caching.Memory est installé pour votre projet. Vous pouvez l'installer en utilisant la console du gestionnaire de packages NuGet avec la commande :

Install-Package Microsoft.Extensions.Caching.Memory

Ou nous pouvons utiliser le gestionnaire de packages NuGet pour installer le package :

Exemple de Microsoft.Extensions.Caching.Memory (Avec PDF) en C# : Figure 1 - Recherchez Microsoft.Extensions.Caching.Memory dans le gestionnaire de packages NuGet et installez-le

Configurer les services dans Startup.cs

Accédez à la méthode ConfigureServices dans votre application ASP.NET Core en ouvrant le fichier Startup.cs. Pour configurer le service de cache en 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
$vbLabelText   $csharpLabel

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

Injecter IMemoryCache

Une fois que le magasin de cache est configuré, toute classe ou composant qui a besoin de mise en cache peut avoir l'interface IMemoryCache injectée en elle. Par exemple, dans un contrôleur ou une classe de service :

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
$vbLabelText   $csharpLabel

Des méthodes pour mettre en cache et récupérer des données de la mémoire sont fournies par l'interface IMemoryCache.

Configurer les options de cache

En définissant des paramètres de cache, vous pouvez modifier le comportement du cache en mémoire, y compris les restrictions de taille, les tactiques d'éviction des entrées de cache et les règles d'expiration des valeurs de cache. Voici une illustration de la manière de définir des 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
$vbLabelText   $csharpLabel

Modifiez les paramètres selon les spécifications de votre application.

Ces instructions vous aideront à configurer Microsoft.Extensions.Caching.Memory dans votre application ASP.NET Core, lui permettant ainsi de fonctionner plus rapidement et efficacement en stockant et récupérant des données fréquemment accédées.

Démarrage

Qu'est-ce qu'IronPDF ?

Avec l'aide de la célèbre bibliothèque .NET IronPDF, les programmeurs peuvent générer, éditer et afficher des documents PDF à l'intérieur d'applications .NET. Créer des PDFs à partir de contenu HTML, d'images ou de données brutes n'est qu'une des nombreuses fonctions qu'il offre pour travailler avec des PDFs. D'autres fonctionnalités incluent l'ajout de texte, d'images et de formes aux documents PDF existants, la conversion de pages HTML en PDFs et l'extraction de texte et d'images à partir de PDFs.

Voici quelques caractéristiques d'IronPDF :

  • Créer des PDFs à partir de HTML, PNGs et de données non traitées.
  • Extraire des images et du texte de PDFs.
  • Ajouter des en-têtes, des pieds de page et des filigranes aux PDF.
  • Documents PDF avec protection par mot de passe et chiffrement.
  • Remplir des formulaires et fournir des possibilités de signature numérique.

Installer le package NuGet

Dans votre projet, assurez-vous que le package IronPDF est installé. La console du Gestionnaire de Packages NuGet 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
$vbLabelText   $csharpLabel

En configurant le service HtmlToPdf d'IronPDF comme singleton, ce code garantit que l'application crée et utilise uniquement une 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 des données fréquemment demandées pour une récupération plus rapide.

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Memory;
using System.Net;
using System.Net.Http.Headers;
using IronPdf;

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;
using IronPdf;

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
Imports IronPdf

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
$vbLabelText   $csharpLabel

Nous importons les espaces de noms requis 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 via HTTP. Une instance de IMemoryCache est injectée dans le constructeur du contrôleur.

Pour contrôler la durée de vie des services, y compris le cache en mémoire, ASP.NET Core offre l'injection de dépendances. Avec l'attribut [HttpGet] appliqué, la méthode Generate est marquée pour gérer les requêtes HTTP GET vers le magasin à partir de l'itinéraire désigné (/Demo). Nous essayons d'obtenir les données PDF du cache en utilisant la clé de cache donnée. Si les données ne sont pas trouvées dans le cache, nous utilisons la fonction GeneratePdf pour créer un nouveau PDF.

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

Pour utiliser Microsoft.Extensions.Caching.Memory, référez-vous à la documentation et au code d'exemple fournis pour mettre en cache les données et améliorer les performances dans les applications ASP.NET Core. En pratique, vous pouvez ajuster les politiques d'expiration, les clés de cache et le comportement de mise en cache pour répondre aux besoins de votre application. Mettre en cache des données coûteuses à générer ou souvent accédées par plusieurs threads peut améliorer l'expérience utilisateur globale et réduire considérablement les temps de réponse.

Exemple de Microsoft.Extensions.Caching.Memory (Avec PDF) en C# : Figure 2 - Exemple de sortie du code ci-dessus

Conclusion

Tout bien considéré, Microsoft.Extensions.Caching.Memory peut être utilisé pour améliorer la scalabilité et la performance 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 utilisateur, réduire 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 pour développer des stratégies de mise en cache adaptées aux besoins spécifiques de l'application, que ce soit pour 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 améliorations de vitesse notables et une réactivité accrue de l'application en adoptant de bonnes pratiques de mise en cache et en ajoutant Microsoft.Extensions.Caching.Memory dans vos applications .NET.

En exploitant les fonctionnalités de Microsoft.Extensions, avec l'aide d'IronPDF pour la création dynamique de PDF et de Caching.Memory pour la mise en cache efficace des données, les développeurs .NET peuvent considérablement améliorer la vitesse de leurs applications. Cette combinaison puissante 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 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 package offre une valeur exceptionnelle puisqu'il commence à $799, un seul frais pour plusieurs systèmes. Pour les utilisateurs avec licences, il offre une aide en ligne ingénierie disponible 24h/24 et 7j/7. Pour plus de détails sur le coût, veuillez visiter la page de licence IronPDF. Visitez cette page sur Iron Software pour en savoir plus sur les produits fabriqués par Iron Software.

Questions Fréquemment Posées

Quel est le but de Microsoft.Extensions.Caching.Memory dans les applications .NET ?

Microsoft.Extensions.Caching.Memory est utilisé pour améliorer la performance des applications .NET en fournissant une mise en cache d'objets en mémoire. Il stocke les données fréquemment consultées en mémoire pour une récupération rapide, ce qui peut être particulièrement bénéfique lorsqu'il est utilisé avec IronPDF pour les opérations PDF.

Comment la mise en cache peut-elle améliorer la performance du traitement des PDF dans .NET ?

La mise en cache peut réduire le temps de traitement et la charge du serveur en stockant les données PDF fréquemment demandées en mémoire. Lorsqu'il est intégré avec une bibliothèque comme IronPDF, il permet une création et une manipulation des PDF plus rapides, améliorant ainsi la vitesse et la réactivité de l'application.

Comment implémentez-vous la mise en cache en mémoire dans une application ASP.NET Core ?

Dans ASP.NET Core, vous pouvez implémenter la mise en cache en mémoire en ajoutant services.AddMemoryCache() dans la méthode ConfigureServices de Startup.cs. Cela s'intègre parfaitement avec IronPDF pour un traitement efficace des PDF et une récupération des données.

Quel est le rôle de IMemoryCache dans la mise en cache ?

IMemoryCache est une interface utilisée dans les applications .NET pour gérer efficacement les entrées du cache. Lorsqu'il est associé à IronPDF, il permet aux développeurs de stocker et de récupérer rapidement les données PDF, améliorant ainsi la performance de l'application.

Quelles sont les options de configuration courantes pour la mise en cache dans .NET ?

Les options de configuration courantes incluent la définition des politiques d'expiration, des limites de taille et des stratégies d'éviction à l'aide de MemoryCacheEntryOptions. Ces configurations optimisent le processus de mise en cache, surtout lors de l'utilisation d'IronPDF pour gérer les PDF.

Comment les développeurs peuvent-ils créer des PDF dynamiques dans une application .NET ?

Les développeurs peuvent utiliser IronPDF pour créer des PDF dynamiques dans les applications .NET. Il prend en charge la conversion HTML en PDF, l'ajout d'en-têtes et de pieds de page, et plus encore, en faisant un outil polyvalent pour la génération et la manipulation de PDF.

Quels sont les avantages d'intégrer la mise en cache avec la génération de PDF dans .NET ?

Intégrer la mise en cache avec la génération de PDF à l'aide d'IronPDF dans les applications .NET peut considérablement améliorer la vitesse et réduire la latence. Cela entraîne une meilleure expérience utilisateur et des applications plus évolutives grâce à un accès plus rapide aux données fréquemment utilisées.

Comment pouvez-vous surveiller et améliorer le système de mise en cache dans les applications .NET ?

Les compteurs de performance peuvent être mis en œuvre pour surveiller l'efficacité du système de mise en cache dans les applications .NET. Cette surveillance permet des ajustements et des améliorations pour garantir des performances optimales, surtout lors de l'utilisation d'IronPDF pour les tâches PDF.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Démarrer l'essai gratuit