Przykład Microsoft.Extensions.Caching.Memory (z plikiem PDF) w języku C#

Microsoft.Extensions.Caching.Memory: Podstawa keszowania w .NET

Buforowanie to metoda stosowana w wielu wysokowydajnych aplikacjach .NET, która polega na przechowywaniu często używanych danych w pamięci w celu ich szybkiego odzyskania. Microsoft.Extensions jest jedna z wielu dostepnych opcji keszowania. Caching.Memory to szczegolnie silna i elastyczna opcja. Ta biblioteka jest czescia wiekszego przestrzeni nazw Microsoft.Extensions.Caching, oferujacego proste, ale skuteczne podejscie do keszowania w pamieci.

Kluczowe typy w "Microsoft.Extensions.Caching.Memory"

Zainstaluj i skonfiguruj Microsoft.Extensions.Caching.Memory

Podczas uruchamiania aplikacji pamięć jest wykorzystywana do konfiguracji usługi pamięci podręcznej w ramach kolekcji usług aplikacji .NET Core. Poniżej znajduje się aplikacja ASP.NET Core z skonfigurowanym Microsoft.Extensions.Caching.Memory:

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

Pierwsze kroki

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

Uzywanie Microsoft.Extensions.Caching.Memory z IronPDF

W aplikacjach .NET, Microsoft.Extensions.Caching.Memory oferuje praktyczny środek przechowywania często wymaganych danych w celu szybszego ich pobierania.

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

Importujemy przestrzenie nazw wymagane do pracy z Microsoft.Extensions.Caching.Memory Microsoft i ASP.NET. Tworzymy kontroler DemoController, ktory pochodzi od ControllerBase. Ten kontroler odpowiedzie na zapytania przeslane przez HTTP. Instancja IMemoryCache jest wstrzykiwana do konstruktora kontrolera.

Aby kontrolować czas działania usług, w tym pamięci podręcznej, .NET Core oferuje wstrzykiwanie zależności. Z atrybutem [HttpGet] zastosowanym, metoda Generate jest oznaczona do obslugi zadania HTTP GET do sklepu z wyznaczonej trasy (/Demo). Próbujemy pobrać dane PDF z pamięci podręcznej przy użyciu podanego klucza pamięci podręcznej. Jesli dane nie zostana znalezione w keszu, uzywamy funkcji GeneratePdf do utworzenia nowego PDF.

W przypadku wielu serwerów aplikacji należy skonfigurować buforowanie rozproszone, aby zapewnić spójną obsługę pamięci podręcznej na wszystkich serwerach.

Aby skorzystać z Microsoft.Extensions.Caching.Memory, odwiedź dokumentację i przykładowy kod dostarczony do keszowania danych i zwiększenia wydajności w aplikacjach ASP.NET Core. W praktyce można dostosować zasady wygasania, klucze pamięci podręcznej i zachowanie pamięci podręcznej do potrzeb aplikacji. Buforowanie danych, których generowanie jest kosztowne lub do których często dostęp ma wiele wątków, może poprawić ogólne wrażenia użytkownika i znacznie skrócić czas odpowiedzi.

Wnioski

Reasumujac, Microsoft.Extensions.Caching.Memory moze byc uzywane do zwiekszenia skalowalnosci i wydajnosci aplikacji .NET, szczegolnie tych opartych na frameworku ASP.NET Core. Programiści mogą poprawić komfort użytkowania, zminimalizować opóźnienia i zoptymalizować dostęp do danych, wykorzystując buforowanie w pamięci. Biblioteka zapewnia elastyczny i przyjazny dla użytkownika interfejs API do opracowywania strategii buforowania dostosowanych do konkretnych wymagań aplikacji, niezależnie od tego, czy chodzi o buforowanie danych referencyjnych, wyników zapytań czy obliczonych wartości. Mozesz osiagnac zauwazalne zwiekszenie szybkosci i lepsza responsywnosc aplikacji, przyjmujac najlepsze praktyki keszowania i dodajac Microsoft.Extensions.Caching.Memory do swoich aplikacji .NET.

Poprzez wykorzystanie funkcji Microsoft.Extensions, przy pomocy IronPDF do dynamicznego tworzenia PDF i Caching.Memory do skutecznego keszowania danych, programisci .NET moga znacznie zwiekszyc szybkosc swoich aplikacji. Ta potężna kombinacja umożliwia programistom łatwe projektowanie aplikacji o wysokiej wydajności, które są skalowalne i responsywne poprzez redukcję obciążenia serwera, usprawnienie doświadczeń użytkowników i eliminację nadmiaru przetwarzania.

IronPDF można nabyć w rozsądnej cenie, a zakup pakietu obejmuje dożywotnią licencję. Pakiet oferuje doskonałą wartość, ponieważ zaczyna się od $999, jednorazowej opłaty za wiele systemów. Użytkownikom posiadającym licencje oferuje całodobową pomoc techniczną online. Więcej informacji na temat opłat można znaleźć na stronie licencyjnej IronPDF. Odwiedź tę stronę poświęconą firmie Iron Software, aby dowiedzieć się więcej o produktach tej firmy.