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.
[Le cache](https://en.wikipedia.org/wiki/Cache_(computing) est une stratégie d'optimisation puissante dans ce contexte. Microsoft.Extensions.Caching.Memory fournit une solution de mise en cache d'objets en mémoire efficace 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 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 .NETLa 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 puissante et adaptable. Cette bibliothèque est un composant du plus grand espace de noms Microsoft.Extensions.Caching offrant une approche de mise en cache en mémoire simple mais efficace.
Microsoft.Extensions.Caching.Memory"IMemoryCacheMemoryCacheIMemoryCache se trouve dans cette classe. Il offre une administration et un stockage réel en mémoire pour les éléments mis en cache.MemoryCache.MemoryCacheEntryOptionsVous 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 :
CacheEntryICacheEntryCacheEntry, qui offre une mise en œuvre pratique de ces fonctionnalités.Microsoft.Extensions.Caching.MemoryLors 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ée :
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 :
Ou nous pouvons utiliser le gestionnaire de packages NuGet pour installer le package :
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...
}Imports Microsoft.Extensions.Caching.Memory
Public Sub ConfigureServices(ByVal services As IServiceCollection)
' Add memory cache service
services.AddMemoryCache()
' Other service configurations...
End SubL'objet du service de cache en mémoire est ajouté à la collection de services de l'application et configuré par ce code. Le service de système de cache en mémoire est enregistré en utilisant ses configurations par défaut via la fonction AddMemoryCache.
IMemoryCacheUne fois le magasin de cache mis en place, toute classe ou composant nécessitant une 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 _cache As IMemoryCache
Public Sub New(ByVal cache As IMemoryCache)
_cache = cache
End Sub
' Use _cache to perform caching operations...
End ClassDes méthodes de mise en cache et de récupération de données de la mémoire sont fournies par l'interface IMemoryCache.
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 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 SubModifiez 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 de fonctionner plus rapidement et plus efficacement en stockant et en récupérant les données souvent consultées.
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 :
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 :
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...
}Imports IronPdf
Public Sub ConfigureServices(ByVal services As IServiceCollection)
' Configure IronPDF
services.AddSingleton(Of HtmlToPdf)()
' Other service configurations...
End SubEn configurant le service HtmlToPdf de IronPDF comme un singleton, ce code garantit que l'application crée et utilise une seule instance de HtmlToPdf.
Microsoft.Extensions.Caching.Memory avec IronPDFDans les applications .NET, Microsoft.Extensions.Caching.Memory offre un moyen pratique de stocker les 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;
}
}
}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 NamespaceNous 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 désignée pour gérer les requêtes HTTP GET vers le magasin depuis 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, reportez-vous à la documentation et au code d'exemple fourni 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.
Tout bien considéré, Microsoft.Extensions.Caching.Memory peut être utilisé pour augmenter la scalabilité et la performance des applications .NET, en particulier celles 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 augmentations de vitesse notables et une réactivité améliorée de l'application en adoptant les meilleures pratiques de mise en cache et en ajoutant Microsoft.Extensions.Caching.Memory dans vos applications .NET.
En tirant parti des fonctionnalités Microsoft.Extensions, avec l'aide de IronPDF pour la création dynamique de PDF et Caching.Memory pour la mise en cache efficace des données, les développeurs .NET peuvent grandement 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 serveur, en améliorant l'expérience utilisateur, et en éliminant les surcharges de traitement.
IronPDF peut être acheté à un prix raisonnable, et l'acquisition du package inclut une licence à vie. Le package offre une valeur exceptionnelle car il commence à $999, une charge unique 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.
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.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
