Para construir aplicações responsivas e eficazes, métodos de otimização são frequentemente necessários para aplicações .NET . O armazenamento em cache é uma abordagem eficaz que consiste em guardar temporariamente, em um cache distribuído, o material frequentemente solicitado para facilitar uma recuperação mais rápida. A redução no tempo de processamento e na carga do servidor com essa estratégia pode levar a um aumento significativo no desempenho do aplicativo. Além disso, contadores de desempenho podem ser implementados para monitorar e aprimorar o sistema de cache.
[Caching](https://en.wikipedia.org/wiki/Cache_(computing) é uma estratégia de otimização potente neste contexto. Microsoft.Extensions.Caching.Memory fornece uma solução eficiente de cache de objetos na memória para aplicativos .NET. Seus aplicativos centrados em PDF irão operar e responder muito mais rápido se você usar estrategicamente o cache MemoryCache junto com o IronPDF.
Exploramos como integrar exemplos Microsoft.Extensions.Caching.Memory em C# com IronPDF de forma eficiente. Neste artigo, discutiremos as vantagens do armazenamento em cache no processo de conversão de HTML para PDF com o IronPDF , abordaremos algumas dicas úteis de implementação e ofereceremos um passo a passo detalhado para configurar o cache no seu programa IronPDF . Ao final, você terá as habilidades e os recursos necessários para desenvolver aplicativos PDF eficazes e intuitivos.
Microsoft.Extensions.Caching.Memory: A Base do Cache em .NETO armazenamento em cache é um método utilizado em muitas aplicações .NET de alto desempenho que armazena dados acessados frequentemente na memória para recuperação rápida. Microsoft.Extensions é uma das muitas opções de cache acessíveis. Caching.Memory é uma opção particularmente forte e adaptável. Esta biblioteca é um componente do maior namespace Microsoft.Extensions.Caching oferecendo uma abordagem de cache na memória simples, mas eficaz.
Microsoft.Extensions.Caching.Memory"IMemoryCacheMemoryCacheIMemoryCache está nesta classe. Oferece administração e armazenamento real em memória para itens em cache.MemoryCache.MemoryCacheEntryOptionsCom essa classe, você pode especificar configurações para itens de cache específicos. Essas configurações regulam coisas como:
CacheEntryICacheEntryCacheEntry, que oferece uma implementação prática desses recursos.Microsoft.Extensions.Caching.MemoryDurante a inicialização da aplicação, a memória é utilizada para configurar o serviço de cache dentro da coleção de serviços da aplicação ASP.NET Core . Abaixo está um aplicativo ASP.NET Core com Microsoft.Extensions.Caching.Memory configurado:
Primeiro, garanta que Microsoft.Extensions.Caching.Memory está instalado em seu projeto. Você pode instalá-lo usando o Console do Gerenciador de Pacotes NuGet com o comando:
Ou podemos usar o Gerenciador de Pacotes NuGet para instalar o pacote:
Navegue até o método ConfigureServices em seu aplicativo ASP.NET Core abrindo o arquivo Startup.cs. Para configurar o serviço de cache de memória, adicione o seguinte código:
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 SubO objeto de serviço de cache de memória é adicionado à coleção de serviços do aplicativo e configurado por este código. O serviço do sistema de cache de memória é registrado usando suas configurações padrão por meio da função AddMemoryCache.
IMemoryCacheUma vez que o armazenamento de cache é configurado, qualquer classe ou componente que precise de cache pode ter a interface IMemoryCache injetada. Em uma classe de controlador ou serviço, por exemplo:
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 ClassMétodos para cache e recuperação de dados da memória são fornecidos pela interface IMemoryCache.
Ao configurar os parâmetros de cache, você pode alterar o comportamento do cache de memória, incluindo restrições de tamanho, táticas de remoção de entradas de cache e regulamentações de expiração de valores de cache. Aqui está uma ilustração de como configurar as opções 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 SubModifique as configurações de acordo com as especificações da sua aplicação.
Essas instruções ajudarão você a configurar Microsoft.Extensions.Caching.Memory em seu aplicativo ASP.NET Core, permitindo que ele opere de maneira mais rápida e eficiente ao armazenar e recuperar dados acessados com frequência.
Com a ajuda da conhecida biblioteca .NET IronPDF, os programadores podem gerar, editar e exibir documentos PDF dentro de aplicativos .NET . Criar PDFs a partir de conteúdo HTML, imagens ou dados brutos é apenas uma das muitas funções que oferece para trabalhar com PDFs. Outras funcionalidades incluem adicionar texto, imagens e formas a documentos PDF preexistentes, converter páginas HTML em PDFs e extrair texto e imagens de PDFs.
Abaixo estão algumas funcionalidades do IronPDF:
No seu projeto, certifique-se de que o pacote IronPDF esteja instalado. O Console do Gerenciador de Pacotes NuGet pode ser usado para instalá-lo:
Para acessar a função ConfigureServices, abra o arquivo Startup.cs em seu aplicativo ASP.NET Core. Para configurar o IronPDF, adicione o seguinte código.
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 SubAo configurar o serviço HtmlToPdf do IronPDF como singleton, este código garante que o aplicativo crie e use apenas uma instância de HtmlToPdf.
Microsoft.Extensions.Caching.Memory com IronPDFEm aplicativos .NET, Microsoft.Extensions.Caching.Memory oferece um meio prático de armazenar dados frequentemente solicitados para recuperação mais rápida.
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 NamespaceImportamos os namespaces necessários para trabalhar com Microsoft e ASP.NET Microsoft.Extensions.Caching.Memory. Criamos o controlador DemoController, que é derivado de ControllerBase. Este controlador irá responder a consultas enviadas via HTTP. Uma instância de IMemoryCache é injetada no construtor do controlador.
Para controlar o ciclo de vida dos serviços, incluindo o cache de memória, o ASP.NET Core oferece injeção de dependência. Com o atributo [HttpGet] aplicado, o método Generate é marcado para tratar requisições HTTP GET ao armazenamento a partir da rota designada (/Demo). Tentamos obter os dados do PDF do cache usando a chave de cache fornecida. Se os dados não forem encontrados no cache, usamos a função GeneratePdf para criar um novo PDF.
Em um cenário com vários servidores de aplicativos, certifique-se de configurar o cache distribuído para um gerenciamento de cache consistente em todos os servidores.
Para utilizar Microsoft.Extensions.Caching.Memory, consulte a documentação e o código de exemplo fornecido para cache de dados e melhoria de desempenho em aplicativos ASP.NET Core. Na prática, você pode ajustar as políticas de expiração, as chaves de cache e o comportamento de cache para atender às necessidades do seu aplicativo. Armazenar em cache dados que são dispendiosos de gerar ou que são frequentemente acessados por várias threads pode melhorar a experiência geral do usuário e reduzir drasticamente os tempos de resposta.
Considerando tudo, Microsoft.Extensions.Caching.Memory pode ser usado para aumentar a escalabilidade e desempenho de aplicativos .NET, especialmente aqueles baseados no framework ASP.NET Core. Os desenvolvedores podem melhorar a experiência do usuário, minimizar a latência e otimizar o acesso aos dados utilizando o cache em memória. A biblioteca fornece uma API flexível e fácil de usar para desenvolver estratégias de cache direcionadas a requisitos específicos de aplicativos, seja para armazenar em cache dados de referência, resultados de consultas ou valores calculados. Você pode obter aumentos de velocidade notáveis e maior capacidade de resposta do aplicativo adotando as melhores práticas de caching e adicionando Microsoft.Extensions.Caching.Memory em seus aplicativos .NET.
Ao aproveitar os recursos Microsoft.Extensions, com a ajuda do IronPDF para criação dinâmica de PDF e Caching.Memory para caching de dados eficaz, desenvolvedores .NET podem melhorar consideravelmente a velocidade de seus aplicativos. Esta combinação potente permite que desenvolvedores projetem facilmente aplicações de alto desempenho, escaláveis e responsivas, reduzindo a carga do servidor, melhorando a experiência do usuário e eliminando sobrecarga de processamento.
O IronPDF pode ser adquirido a um preço razoável, e a compra do pacote inclui uma licença vitalícia. O pacote oferece um valor excepcional sendo que começa em $999, um único custo para vários sistemas. Para usuários com licenças, oferece suporte técnico online 24 horas por dia, 7 dias por semana. Para obter mais detalhes sobre a cobrança, visite a página de licenciamento do IronPDF . Visite esta página sobre a Iron Software para saber mais sobre os produtos fabricados pela Iron Software.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
