O armazenamento em cache é uma técnica fundamental no desenvolvimento de software para melhorar o desempenho, armazenando dados acessados com frequência na memória ou em um meio de armazenamento mais rápido. Em C#, LazyCache é uma biblioteca popular que simplifica a implementação de cache thread-safe, facilitando aos desenvolvedores o aproveitamento eficaz do cache em suas aplicações em cenários de alta carga.
O que é LazyCache?
LazyCache é uma biblioteca provedora de cache subjacente para aplicações .NET/ASP.NET Core que oferece uma API simples e intuitiva para armazenar dados em cache. Está disponível como um pacote NuGet e pode ser facilmente integrado em projetos C#. O principal objetivo do LazyCache é simplificar a implementação do cache e reduzir o código repetitivo necessário para gerenciar informações em cache, utilizando um padrão de cache com bloqueio duplo.
Principais funcionalidades do LazyCache:
API simples: O LazyCache oferece uma API direta para adicionar, recuperar e remover itens em cache. Os desenvolvedores podem integrar rapidamente o cache em seus aplicativos ou chamadas de serviços web sem precisar lidar com mecanismos de cache complexos.
Expiração automática: O LazyCache suporta a expiração automática de itens em cache com base em políticas de expiração configuráveis. Os desenvolvedores podem especificar a duração de expiração dos itens em cache, e o LazyCache remove os itens expirados dos dados em cache.
Cache em memória: O LazyCache armazena itens em cache na memória por padrão, tornando-o adequado para cenários onde é necessário acesso rápido aos dados em cache. O armazenamento em cache na memória garante baixa latência e alta taxa de transferência para o acesso a dados armazenados em cache.
Operações seguras para threads: O LazyCache oferece operações seguras para threads para adicionar, recuperar e remover itens em cache. Isso garante que várias threads possam acessar o cache simultaneamente sem o risco de corrupção ou inconsistência de dados.
Extensibilidade: O LazyCache foi projetado para ser extensível, permitindo que os desenvolvedores personalizem o comportamento do cache de acordo com suas necessidades específicas. Ele fornece mecanismos para implementar estratégias de cache personalizadas, como cache distribuído ou cache com persistência.
Como usar o LazyCache em C#:
Usar o LazyCache em C# é simples, graças à sua API intuitiva. Abaixo, segue um exemplo básico que demonstra como usar o LazyCache para armazenar em cache o resultado de uma chamada de método:
using LazyCache;
public class DataService
{
// Define a private readonly field for the cache
private readonly IAppCache _cache;
// Constructor to initialize the cache
public DataService(IAppCache cache)
{
_cache = cache;
}
// Method to retrieve data (cached or fetched)
public string GetData()
{
return _cache.GetOrAdd("dataKey", () =>
{
// Simulate expensive operation such as database calls
return FetchDataFromDatabase();
});
}
// Simulate fetching data from a database
private string FetchDataFromDatabase()
{
return "Cached Data";
}
}Imports LazyCache
Public Class DataService
' Define a private readonly field for the cache
Private ReadOnly _cache As IAppCache
' Constructor to initialize the cache
Public Sub New(ByVal cache As IAppCache)
_cache = cache
End Sub
' Method to retrieve data (cached or fetched)
Public Function GetData() As String
Return _cache.GetOrAdd("dataKey", Function()
' Simulate expensive operation such as database calls
Return FetchDataFromDatabase()
End Function)
End Function
' Simulate fetching data from a database
Private Function FetchDataFromDatabase() As String
Return "Cached Data"
End Function
End ClassNeste exemplo, a classe DataService usa LazyCache para armazenar em cache o resultado do método GetData(). O método GetOrAdd() recupera os dados em cache associados à chave especificada ("dataKey") se ela existir. Se os dados não estiverem em cache, o delegado fornecido FetchDataFromDatabase() é executado para buscar os dados, que são então armazenados em cache para uso futuro.
IronPDF é uma poderosa biblioteca C# para PDF que permite gerar, editar e extrair conteúdo de documentos PDF em projetos .NET . Aqui estão algumas características principais:
Conversão de HTML para PDF:
Conversão de imagem e conteúdo:
Edição e Manipulação:
Suporte multiplataforma:
Para começar, crie um aplicativo de console usando o Visual Studio, conforme mostrado abaixo.
Informe o nome do projeto.
Informe a versão do .NET .
Instale o pacote IronPDF .
Instale o pacote LazyCache para adicionar chamadas de método em cache.
using LazyCache;
using IronPdf; // Add the IronPdf namespace
using System;
namespace CodeSample
{
internal class LazyCacheDemo
{
public static void Execute()
{
// Instantiate the Chrome PDF Renderer
var renderer = new ChromePdfRenderer();
var content = "<h1>Demo LazyCache and IronPDF</h1>";
content += "<h2>Create CachingService</h2>";
// Create the cache service using LazyCache
IAppCache cache = new CachingService();
var cacheKey = "uniqueKey"; // Unique key for caching the content
// Define a factory method to generate the cacheable data
Func<string> expensiveLongRunMethod = () =>
{
// Render the HTML content to a PDF
var pdf = renderer.RenderHtmlAsPdf(content);
// Export the rendered PDF to a file
pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf");
// Return the content as a string
return content;
};
// Get the cached value or execute expensiveLongRunMethod to cache it
string cachedValue = cache.GetOrAdd(cacheKey, expensiveLongRunMethod);
// Output the cached value to the console
Console.WriteLine(cachedValue);
}
}
}Imports LazyCache
Imports IronPdf ' Add the IronPdf namespace
Imports System
Namespace CodeSample
Friend Class LazyCacheDemo
Public Shared Sub Execute()
' Instantiate the Chrome PDF Renderer
Dim renderer = New ChromePdfRenderer()
Dim content = "<h1>Demo LazyCache and IronPDF</h1>"
content &= "<h2>Create CachingService</h2>"
' Create the cache service using LazyCache
Dim cache As IAppCache = New CachingService()
Dim cacheKey = "uniqueKey" ' Unique key for caching the content
' Define a factory method to generate the cacheable data
Dim expensiveLongRunMethod As Func(Of String) = Function()
' Render the HTML content to a PDF
Dim pdf = renderer.RenderHtmlAsPdf(content)
' Export the rendered PDF to a file
pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf")
' Return the content as a string
Return content
End Function
' Get the cached value or execute expensiveLongRunMethod to cache it
Dim cachedValue As String = cache.GetOrAdd(cacheKey, expensiveLongRunMethod)
' Output the cached value to the console
Console.WriteLine(cachedValue)
End Sub
End Class
End NamespaceInstanciar Renderizador: Uma instância de ChromePdfRenderer é criada para lidar com a conversão de conteúdo HTML em formato PDF.
Define Content: HTML content ("
Criar Serviço de Cache: Um serviço de cache (IAppCache) é instanciado usando CachingService do LazyCache. Este serviço de cache preguiçoso gerencia o armazenamento e a recuperação de dados em cache.
Chave de cache: Um identificador único ("uniqueKey") é atribuído para representar o conteúdo do PDF armazenado em cache.
Definir Método Caro: Um método de fábrica (expensiveLongRunMethod) é definido para gerar os dados armazenáveis em cache. Este método invoca o ChromePdfRenderer para renderizar conteúdo HTML como um PDF. O PDF resultante é então salvo e retornado como uma string.
Obter ou Adicionar ao Cache: O método GetOrAdd do serviço é chamado para recuperar o valor em cache associado ao cacheKey. Se o valor não existir no cache, expensiveLongRunMethod é invocado para calculá-lo, armazená-lo no cache e retorná-lo. Se o valor já estiver em cache, ele será retornado diretamente.
Saída: O conteúdo PDF em cache (como uma string) é impresso no console (Console.WriteLine(cachedValue)), demonstrando a recuperação de dados em cache.
O pacote IronPDF requer uma licença para ser executado e gerar o PDF. Adicione o seguinte código no início da aplicação, antes que o pacote seja acessado.
IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";Imports IronPdf
IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY"Uma licença de avaliação está disponível na página de licenças de avaliação do IronPDF .
O LazyCache simplifica a implementação de cache em aplicações C# ao fornecer uma API direta e expiração automática dos itens em cache. Ao integrar o LazyCache em seus projetos, você pode melhorar o desempenho armazenando em cache de forma eficiente os dados acessados com frequência, reduzindo a latência e otimizando a utilização de recursos de maneira atômica e organizada. Seja para o desenvolvimento de aplicações web, APIs ou serviços, o LazyCache pode ser uma ferramenta valiosa para melhorar o desempenho e a escalabilidade das suas aplicações C#.
Por outro lado, o IronPDF se destaca como uma biblioteca C# poderosa e versátil para manipulação de documentos PDF em aplicações .NET . Suas robustas funcionalidades abrangem a criação, edição e renderização de HTML para PDF, além da manipulação programática de PDFs. Com recursos para o manuseio seguro de documentos por meio de criptografia e assinaturas digitais, o IronPDF permite que os desenvolvedores gerenciem e personalizem fluxos de trabalho em PDF de forma eficiente, tornando-se uma ferramenta valiosa para uma ampla gama de tarefas de gerenciamento e geração de documentos no desenvolvimento em C#.
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.
