Exemplo de Microsoft.Extensions.Caching.Memory (com PDF) em C#

Microsoft.Extensions.Caching.Memory: Os fundamentos do cache no .NET

O 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 disponíveis. Caching.Memory é uma opção particularmente forte e adaptável. Esta biblioteca é um componente do namespace maior Microsoft.Extensions.Caching, que oferece uma abordagem de cache em memória simples, porém eficaz.

Tipos de chave dentro de "Microsoft.Extensions.Caching.Memory"

Instalar e configurar Microsoft.Extensions.Caching.Memory

Durante 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:

Install-Package Microsoft.Extensions.Caching.Memory

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

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

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

Começando

Install-Package IronPdf

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

Usando Microsoft.Extensions.Caching.Memory com IronPDF

Em aplicações .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;
        }
    }
}

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

Importamos 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 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 lidar com solicitações HTTP GET para o 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 o Microsoft.Extensions.Caching.Memory, consulte a documentação e o código de exemplo fornecidos para armazenar dados em cache e melhorar o 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.

Conclusão

Levando tudo em consideração, Microsoft.Extensions.Caching.Memory pode ser usado para aumentar a escalabilidade e o 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 cache e adicionando Microsoft.Extensions.Caching.Memory aos seus aplicativos .NET .

Ao aproveitar os recursos do Microsoft.Extensions, com a ajuda do IronPDF para criação dinâmica de PDFs e do Caching.Memory para armazenamento em cache eficiente de dados, os desenvolvedores .NET podem aumentar significativamente a velocidade de seus aplicativos. Essa poderosa combinação permite que os desenvolvedores criem facilmente aplicativos de alto desempenho, escaláveis ​​e responsivos, reduzindo a carga do servidor, melhorando a experiência do usuário e eliminando a 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 excelente custo-benefício, pois começa em $799, uma taxa única 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.