Buforowanie jest podstawową techniką stosowaną w tworzeniu oprogramowania w celu poprawy wydajności poprzez przechowywanie często używanych danych w pamięci lub na szybszym nośniku danych. W języku C# LazyCache to popularna biblioteka, która upraszcza implementację pamięci podręcznej bezpiecznej dla wątków, ułatwiając programistom skuteczne wykorzystanie buforowania w aplikacjach przeznaczonych do pracy w warunkach dużego obciążenia.

Czym jest LazyCache?

LazyCache to biblioteka dostawcy buforowania dla aplikacji .NET/ASP.NET Core, która zapewnia proste i intuicyjne API do buforowania danych. Jest dostępny jako pakiet NuGet i można go łatwo zintegrować z projektami C#. Głównym celem LazyCache jest uproszczenie implementacji buforowania oraz ograniczenie ilości kodu szablonowego niezbędnego do zarządzania buforowanymi informacjami przy użyciu wzorca podwójnego blokowania pamięci podręcznej.

Najważniejsze cechy LazyCache:

1. Proste API: LazyCache zapewnia proste API do dodawania, pobierania i usuwania elementów z pamięci podręcznej. Programiści mogą szybko zintegrować buforowanie z aplikacjami lub wywołaniami usług internetowych bez konieczności zajmowania się skomplikowanymi mechanizmami buforowania.

2. Automatyczne wygasanie: LazyCache obsługuje automatyczne wygasanie elementów z pamięci podręcznej w oparciu o konfigurowalne zasady wygasania. Programiści mogą określić czas wygaśnięcia elementów w pamięci podręcznej, a LazyCache usuwa wygasłe elementy z danych pamięci podręcznej.

3. Buforowanie w pamięci: LazyCache domyślnie przechowuje buforowane elementy w pamięci, dzięki czemu nadaje się do scenariuszy, w których wymagany jest szybki dostęp do buforowanych danych. Buforowanie w pamięci zapewnia niskie opóźnienia i wysoką przepustowość dostępu do danych w pamięci podręcznej.

4. Operacje bezpieczne dla wątków: LazyCache zapewnia operacje bezpieczne dla wątków w zakresie dodawania, pobierania i usuwania elementów z pamięci podręcznej. Gwarantuje to, że wiele wątków może uzyskać dostęp do pamięci podręcznej jednocześnie bez ryzyka uszkodzenia danych lub niespójności.

5. Rozszerzalność: LazyCache został zaprojektowany z myślą o rozszerzalności, umożliwiając programistom dostosowanie zachowania pamięci podręcznej do ich konkretnych wymagań. Zapewnia punkty zaczepienia do wdrażania niestandardowych strategii buforowania, takich jak buforowanie rozproszone lub buforowanie z trwałością.

Jak korzystać z LazyCache w języku C#:

Korzystanie z LazyCache w języku C# jest proste dzięki intuicyjnemu interfejsowi API. Poniżej znajduje się podstawowy przykład pokazujący, jak używać LazyCache do buforowania wyniku wywołania metody:

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";
    }
}

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 Class

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 Class

W tym przykładzie klasa DataService wykorzystuje LazyCache do buforowania wyniku metody GetData(). Metoda GetOrAdd() pobiera zbuforowane dane powiązane z określonym kluczem ("dataKey"), jeśli istnieją. Jeśli dane nie są zbuforowane, wykonany zostaje dostarczony delegat FetchDataFromDatabase(), aby pobrać dane, które następnie są buforowane do przyszłego użytku.

Wprowadzenie do IronPDF

IronPDF to potężna biblioteka C# do obsługi plików PDF, która umożliwia generowanie, edycję i wyodrębnianie treści z dokumentów PDF w projektach .NET. Oto kilka kluczowych funkcji:

1. Konwersja HTML do PDF:

   • Konwersja treści HTML, CSS i JavaScript do formatu PDF.
   • Użyj silnika renderującego Chrome, aby uzyskać pliki PDF o idealnej rozdzielczości.
   • Generuj pliki PDF z adresów URL, plików HTML lub ciągów znaków HTML.

2. Konwersja obrazów i treści:

   • Konwertuj obrazy do i z formatu PDF.
   • Wyodrębnianie tekstu i obrazów z istniejących plików PDF.
   • Obsługa różnych formatów obrazów.

3. Edycja i obróbka:

   • Ustawianie właściwości, zabezpieczeń i uprawnień dla plików PDF.
   • Dodaj podpisy cyfrowe.
   • Edytuj metadane i historię zmian.

4. Obsługa wielu platform:

   • Działa z .NET Core (8, 7, 6, 5 i 3.1+), .NET Standard (2.0+) oraz .NET Framework (4.6.2+).
   • Kompatybilny z systemami Windows, Linux i macOS.
   • Dostępne w serwisie NuGet, co ułatwia instalację.

Generowanie dokumentu PDF przy użyciu IronPDF i LazyCache

Na początek utwórz aplikację konsolową za pomocą programu Visual Studio, jak pokazano poniżej.

Podaj nazwę projektu.

Podaj wersję .NET.

Zainstaluj pakiet IronPDF.

Zainstaluj pakiet LazyCache, aby dodać buforowane wywołania metod.

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);
        }
    }
}

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 Namespace

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 Namespace

Wyjaśnienie kodu

• Instancja Renderer: Zostaje utworzona instancja ChromePdfRenderer w celu obsługi konwersji treści HTML na format PDF.

• Define Content: HTML content ("

  Demo LazyCache and IronPDF

  ", "

  Create CachingService

  ", etc.) is prepared. Treść ta zostanie przekształcona do formatu PDF i zapisana w pamięci podręcznej w celu ponownego wykorzystania.

• Utwórz usługę buforującą: Usługa buforowania (IAppCache) jest tworzona przy użyciu CachingService z LazyCache. Ta usługa leniwego buforowania zarządza przechowywaniem i pobieraniem danych z pamięci podręcznej.

• Klucz pamięci podręcznej: Przypisywany jest unikalny identyfikator ("uniqueKey") reprezentujący zawartość pliku PDF w pamięci podręcznej.

• Zdefiniuj kosztochłonną metodę: Definiowana jest metoda fabryczna (expensiveLongRunMethod) w celu generowania danych do buforowania. Ta metoda wywołuje ChromePdfRenderer w celu renderowania treści HTML jako PDF. Powstały plik PDF jest następnie zapisywany i zwracany jako ciąg znaków.

• Pobierz lub dodaj do buforu: Wywoływana jest metoda GetOrAdd usługi w celu pobrania zbuforowanej wartości powiązanej z cacheKey. Jeśli wartość nie istnieje w buforze, wywoływana jest expensiveLongRunMethod w celu jej obliczenia, zapisania w buforze i zwrócenia. Jeśli wartość jest już zapisana w pamięci podręcznej, jest zwracana bezpośrednio.

• Wynik: Zbuforowana treść PDF (jako ciąg znaków) jest drukowana na konsolę (Console.WriteLine(cachedValue)), demonstrując odzyskiwanie danych z bufora.

Wynik

PDF

Licencjonowanie IronPDF (dostępna wersja próbna)

Pakiet IronPDF wymaga licencji do uruchomienia i generowania plików PDF. Dodaj poniższy kod na początku aplikacji, zanim nastąpi dostęp do pakietu.

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";

Imports IronPdf

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY"

Imports IronPdf

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY"

Licencja Trial jest dostępna na stronie licencji Trial IronPDF.

Wnioski

LazyCache upraszcza implementację buforowania w aplikacjach C#, zapewniając prosty interfejs API oraz automatyczne wygasanie elementów z bufora. Dzięki integracji LazyCache z projektami można poprawić wydajność poprzez efektywne buforowanie często używanych danych, zmniejszenie opóźnień oraz optymalizację wykorzystania zasobów w sposób atomowy i uporządkowany. Niezależnie od tego, czy tworzysz aplikacje internetowe, interfejsy API czy usługi, LazyCache może być cennym narzędziem zwiększającym wydajność i skalowalność Twoich aplikacji napisanych w języku C#.

Z drugiej strony IronPDF wyróżnia się jako potężna i wszechstronna biblioteka C# do obsługi dokumentów PDF w aplikacjach .NET. Jego rozbudowane możliwości obejmują tworzenie, edycję, renderowanie HTML do PDF oraz programową obróbkę plików PDF. Dzięki funkcjom bezpiecznego przetwarzania dokumentów poprzez szyfrowanie i podpisy cyfrowe, IronPDF umożliwia programistom efektywne zarządzanie i dostosowywanie procesów pracy z plikami PDF, co czyni go cennym narzędziem do szerokiego zakresu zadań związanych z zarządzaniem dokumentami i ich generowaniem w programowaniu w języku C#.