Caching ist eine grundlegende Technik in der Softwareentwicklung zur Leistungsverbesserung, indem häufig zugegriffene Daten im Speicher oder einem schnelleren Speichermedium gespeichert werden. In C# ist LazyCache eine beliebte Bibliothek, die die threadsichere Cache-Implementierung vereinfacht und Entwicklern erleichtert, Caching in ihren Anwendungen für stark ausgelastete Szenarien effektiv zu nutzen.

Was ist LazyCache?

LazyCache ist eine zugrunde liegende Cache-Anbieterbibliothek für .NET/ASP.NET Core-Anwendungen, die eine einfache und intuitive API für das Caching von Daten bereitstellt. Es ist als NuGet-Paket verfügbar und kann leicht in C#-Projekte integriert werden. Das Hauptziel von LazyCache ist es, die Cache-Implementierung zu vereinfachen und den Boilerplate-Code zu reduzieren, der erforderlich ist, um zwischengespeicherte Informationen mithilfe eines doppelten Sperrmusters zu verwalten.

Hauptmerkmale von LazyCache:

1. Einfache API: LazyCache bietet eine unkomplizierte API zum Hinzufügen, Abrufen und Entfernen zwischengespeicherter Elemente. Entwickler können Caching schnell in ihre Anwendungen oder Webdienstaufrufe integrieren, ohne sich mit komplexen Caching-Mechanismen auseinandersetzen zu müssen.

2. Automatische Ablauffrist: LazyCache unterstützt das automatische Ablaufen zwischengespeicherter Elemente basierend auf konfigurierbaren Ablaufrichtlinien. Entwickler können die Ablaufdauer für zwischengespeicherte Elemente angeben, und LazyCache entfernt abgelaufene Elemente aus den Cache-Daten.

3. In-Memory-Caching: LazyCache speichert zwischengespeicherte Elemente standardmäßig im Speicher, wodurch es für Szenarien geeignet ist, in denen ein schneller Zugriff auf zwischengespeicherte Daten erforderlich ist. In-Memory-Caching sorgt für niedrige Latenzen und hohen Durchsatz bei cached Daten.

4. Thread-sichere Operationen: LazyCache bietet thread-sichere Operationen zum Hinzufügen, Abrufen und Entfernen zwischengespeicherter Elemente. Dies stellt sicher, dass mehrere Threads gleichzeitig auf den Cache zugreifen können, ohne das Risiko von Datenkorruption oder Inkonsistenz.

5. Erweiterbarkeit: LazyCache ist so konzipiert, dass es erweiterbar ist und Entwickler das Caching-Verhalten an ihre spezifischen Anforderungen anpassen können. Es bietet Hooks zur Implementierung benutzerdefinierter Caching-Strategien, wie z. B. verteiltes Caching oder Caching mit Persistenz.

Wie man LazyCache in C# verwendet:

Die Verwendung von LazyCache in C# ist dank seiner intuitiven API unkompliziert. Im Folgenden wird ein einfaches Beispiel gezeigt, wie man LazyCache zur Zwischenspeicherung des Ergebnisses eines Methodenaufrufs verwendet:

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

In diesem Beispiel verwendet die DataService-Klasse LazyCache, um das Ergebnis der GetData()-Methode zwischenspeichern. Die GetOrAdd()-Methode ruft die zwischengespeicherten Daten ab, die mit dem angegebenen Schlüssel ("dataKey") verbunden sind, falls sie existieren. Wenn die Daten nicht zwischengespeichert sind, wird der bereitgestellte Delegat FetchDataFromDatabase() ausgeführt, um die Daten abzurufen, die dann für zukünftige Verwendung zwischengespeichert werden.

Einführung in IronPDF

IronPDF ist eine leistungsstarke C#-PDF-Bibliothek, die das Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dokumenten in .NET-Projekten ermöglicht. Hier sind einige wichtige Funktionen:

1. HTML-zu-PDF-Konvertierung:

   • Konvertieren Sie HTML-, CSS- und JavaScript-Inhalte in das PDF-Format.
   • Verwenden Sie die Chrome-Rendering-Engine für pixelgenaue PDFs.
   • PDFs aus URLs, HTML-Dateien oder HTML-Strings erstellen.

2. Bild- und Inhaltskonvertierung:

   • Konvertieren Sie Bilder in und aus PDF.
   • Extrahieren Sie Text und Bilder aus bestehenden PDFs.
   • Unterstützung für verschiedene Bildformate.

3. Bearbeitung und Manipulation:

   • Setzen Sie Eigenschaften, Sicherheit und Berechtigungen für PDFs.
   • Fügen Sie digitale Signaturen hinzu.
   • Metadaten und Versionsverlauf bearbeiten.

4. Plattformübergreifende Unterstützung:

   • Funktioniert mit .NET Core (8, 7, 6, 5 und 3.1+), .NET Standard (2.0+) und .NET Framework (4.6.2+).
   • Kompatibel mit Windows, Linux und macOS.
   • Auf NuGet für eine einfache Installation verfügbar.

PDF-Dokument mit IronPDF und LazyCache generieren

Erstellen Sie zunächst eine Konsolenanwendung mit Visual Studio wie unten beschrieben.

Projektname bereitstellen.

Geben Sie die .NET-Version an.

IronPDF-Paket installieren.

Installieren Sie das LazyCache-Paket für zwischengespeicherte Methodenaufrufe.

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

Code-Erklärung

• Renderer instanziieren: Eine Instanz von ChromePdfRenderer wird erstellt, um die Umwandlung von HTML-Inhalten in das PDF-Format zu verwalten.

• Define Content: HTML content ("

  Demo LazyCache and IronPDF

  ", "

  Create CachingService

  ", etc.) is prepared. Dieser Inhalt wird in ein PDF gerendert und zur Wiederverwendung zwischengespeichert.

• Cache-Service erstellen: Ein Caching-Service (IAppCache) wird mit LazyCache's CachingService instanziiert. Dieser Lazy-Cache-Dienst verwaltet die Speicherung und den Abruf zwischengespeicherter Daten.

• Cache-Schlüssel: Ein eindeutiger Bezeichner ("uniqueKey") wird zugewiesen, um den zwischengespeicherten PDF-Inhalt darzustellen.

• Kostenintensive Methode definieren: Eine Fabrikmethode (expensiveLongRunMethod) wird definiert, um die zwischenspeicherbaren Daten zu generieren. Diese Methode ruft die ChromePdfRenderer auf, um HTML-Inhalt als PDF darzustellen. Das resultierende PDF wird dann gespeichert und als Zeichenkette zurückgegeben.

• Cache abrufen oder hinzufügen: Die GetOrAdd-Methode des Dienstes wird aufgerufen, um den zwischengespeicherten Wert abzurufen, der mit der cacheKey verbunden ist. Wenn der Wert nicht im Cache existiert, wird expensiveLongRunMethod aufgerufen, um ihn zu berechnen, im Cache zu speichern und zurückzugeben. Wenn der Wert bereits zwischengespeichert ist, wird er direkt zurückgegeben.

• Ausgabe: Der zwischengespeicherte PDF-Inhalt (als Zeichenkette) wird auf die Konsole (Console.WriteLine(cachedValue)) gedruckt, um die Wiedergewinnung der zwischengespeicherten Daten zu demonstrieren.

Ausgabe

PDF

IronPDF-Lizenzierung (Testversion verfügbar)

Das IronPDF-Paket erfordert eine Lizenz zum Ausführen und Erstellen des PDFs. Fügen Sie den folgenden Code am Anfang der Anwendung hinzu, bevor das Paket aufgerufen wird.

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"

Eine Testlizenz ist auf der Testlizenz-Seite von IronPDF verfügbar.

Abschluss

LazyCache vereinfacht die Implementierung von Caching in C#-Anwendungen durch die Bereitstellung einer unkomplizierten API und das automatische Ablaufen zwischengespeicherter Elemente. Durch die Integration von LazyCache in Ihre Projekte können Sie die Leistung verbessern, indem Sie häufig zugegriffene Daten effizient zwischenspeichern, die Latenz reduzieren und die Ressourcennutzung auf atomare und ordentliche Weise optimieren. Egal, ob Sie Webanwendungen, APIs oder Dienste entwickeln, LazyCache kann ein wertvolles Werkzeug zur Verbesserung der Leistung und Skalierbarkeit Ihrer C#-Anwendungen sein.

IronPDF hingegen zeichnet sich als leistungsstarke und vielseitige C#-Bibliothek für die Verarbeitung von PDF-Dokumenten innerhalb von .NET-Anwendungen aus. Seine robusten Fähigkeiten umfassen das Erstellen, Bearbeiten, Rendern von HTML zu PDF und das programmgesteuerte Bearbeiten von PDFs. Mit Funktionen zur sicheren Dokumentenverarbeitung durch Verschlüsselung und digitale Signaturen ermöglicht IronPDF Entwicklern, PDF-Workflows effizient zu verwalten und anzupassen, was es zu einem wertvollen Werkzeug für eine Vielzahl von Dokumentenverwaltungs- und -erstellungsaufgaben in der C#-Entwicklung macht.