Zum Fußzeileninhalt springen
.NET HILFE

LazyCache C# (Wie es für Entwickler funktioniert)

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";
    }
}
$vbLabelText   $csharpLabel

In diesem Beispiel verwendet die DataService-Klasse LazyCache zur Zwischenspeicherung des Ergebnisses der GetData()-Methode. Die Methode GetOrAdd() ruft die zwischengespeicherten Daten ab, die mit dem angegebenen Schlüssel ("dataKey") verknüpft sind, wenn sie existieren. Wenn die Daten nicht zwischengespeichert sind, wird der bereitgestellte Delegierte FetchDataFromDatabase() ausgeführt, um die Daten abzurufen, die dann für die zukünftige Verwendung zwischengespeichert werden.

Einführung in IronPDF

LazyCache C# (Wie es für Entwickler funktioniert): Abbildung 1 - 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.

LazyCache C# (Wie es für Entwickler funktioniert): Abbildung 2 - Konsolenanwendung

Projektname bereitstellen.

LazyCache C# (Wie es für Entwickler funktioniert): Abbildung 3 - Projektkonfiguration

Geben Sie die .NET-Version an.

LazyCache C# (Wie es für Entwickler funktioniert): Abbildung 4 - Ziel-Framework

IronPDF-Paket installieren.

LazyCache C# (Wie es für Entwickler funktioniert): Abbildung 5 - IronPDF

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

LazyCache C# (Wie es für Entwickler funktioniert): Abbildung 6 - LazyCache

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);
        }
    }
}
$vbLabelText   $csharpLabel

Code-Erklärung

  • Renderer instanziieren: Es wird eine Instanz von ChromePdfRenderer erstellt, um die Konvertierung von HTML-Inhalten in das PDF-Format zu handhaben.

  • 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-Dienst erstellen: Ein Caching-Dienst ( IAppCache ) wird mithilfe CachingService von LazyCache 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.

  • Definition einer aufwändigen Methode: Es wird eine Factory-Methode ( expensiveLongRunMethod ) definiert, um die zwischenspeicherbaren Daten zu generieren. Diese Methode ruft den ChromePdfRenderer auf, um HTML-Inhalte als PDF zu rendern. Das resultierende PDF wird dann gespeichert und als Zeichenkette zurückgegeben.

  • Abrufen oder Hinzufügen zum Cache: Die GetOrAdd Methode des Dienstes wird aufgerufen, um den dem cacheKey zugeordneten zwischengespeicherten Wert abzurufen. Wenn der Wert nicht im Cache vorhanden ist, 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 in der Konsole ausgegeben ( Console.WriteLine(cachedValue) ), wodurch das Abrufen zwischengespeicherter Daten demonstriert wird.

Ausgabe

LazyCache C# (Wie es für Entwickler funktioniert): Abbildung 7 - Konsolenausgabe

PDF

LazyCache C# (Wie es für Entwickler funktioniert): Abbildung 8 - PDF-Ausgabe

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";
$vbLabelText   $csharpLabel

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.

Häufig gestellte Fragen

Was ist LazyCache und wie profitiert es .NET-Anwendungen?

LazyCache ist eine Caching-Provider-Bibliothek, die für .NET/ASP.NET Core-Anwendungen entwickelt wurde. Sie profitiert diesen Anwendungen, indem sie die Implementierung von Caching vereinfacht, Boilerplate-Code reduziert und die Leistung durch In-Memory-Datenspeicherung verbessert, was unnötige Datenabrufoperationen minimiert.

Wie kann man Caching in C# mit LazyCache implementieren?

Um Caching in C# mit LazyCache zu implementieren, müssen Sie die Bibliothek über NuGet installieren und einen Caching-Dienst mit dem CachingService von LazyCache einrichten. Sie können Daten cachen, indem Sie die GetOrAdd-Methode verwenden, die das Ergebnis von Methodenaufrufen speichert und einen eindeutigen Schlüssel sowie einen Delegaten bereitstellt, um Daten abzurufen, wenn sie nicht bereits im Cache sind.

Wie sorgt LazyCache dafür, dass die Daten im Cache aktuell bleiben?

LazyCache stellt sicher, dass Daten aktuell bleiben, indem es die automatische Ablaufzeit von gecachten Elementen basierend auf konfigurierbaren Richtlinien unterstützt. Diese Funktion ermöglicht es Entwicklern, Ablaufzeiten festzulegen und sicherzustellen, dass veraltete Daten nicht an Benutzer ausgeliefert werden.

Was macht LazyCache thread-sicher?

LazyCache ist thread-sicher aufgrund seines Designs, das es mehreren Threads ermöglicht, mit dem Cache zu interagieren, ohne das Risiko einer Datenkorruption einzugehen. Es verwendet einen Doppelverriegelungsmechanismus, um sicherzustellen, dass Cache-Operationen in multithreaded-Anwendungen sicher ausgeführt werden.

Wie kann man das Management von PDF-Dokumenten in C#-Projekten optimieren?

Sie können das Management von PDF-Dokumenten in C#-Projekten mithilfe von IronPDF optimieren, das robuste Funktionen wie HTML zu PDF-Konvertierung, Inhaltsextraktion und PDF-Bearbeitung bietet. Es unterstützt plattformübergreifende Kompatibilität und kann mit LazyCache integriert werden, um generierte PDFs zu cachen und die Leistung zu verbessern.

Ist es möglich, LazyCache für verteiltes Caching zu verwenden?

Ja, LazyCache bietet Erweiterbarkeit, die es Entwicklern ermöglicht, benutzerdefinierte Caching-Strategien zu implementieren, einschließlich verteiltem Caching. Diese Flexibilität ermöglicht die Integration mit anderen Caching-Systemen zur Unterstützung verteilter Umgebungen.

Welche Vorteile bietet die Verwendung einer C# PDF-Bibliothek zusammen mit LazyCache?

Die Verwendung einer C# PDF-Bibliothek wie IronPDF zusammen mit LazyCache ermöglicht es Ihnen, PDF-Dokumente effizient zu erstellen und zu cachen. Diese Kombination verbessert die Anwendungsleistung, indem redundante PDF-Generierungen vermieden und schneller Zugriff auf häufig angeforderte Dokumente ermöglicht wird.

Welche Lizenzanforderungen gibt es für die Verwendung einer C# PDF-Bibliothek wie IronPDF?

IronPDF erfordert eine Lizenz, um seine volle Funktionalität zu nutzen. Entwickler können mit einer Testlizenz beginnen, die auf der IronPDF-Website verfügbar ist, und müssen den Lizenzschlüssel in ihrem Anwendungscode einbinden, um die Bibliothek für die PDF-Erstellung zu aktivieren.

Wie verbessert LazyCache die Anwendungsleistung?

LazyCache verbessert die Anwendungsleistung, indem häufig zugegriffene Daten im Speicher gespeichert werden und der Bedarf an wiederholten Datenabrufoperationen reduziert wird. Dies führt zu schnelleren Antwortzeiten und einer Entlastung von Datenbanken oder externen Datenquellen.

Jacob Mellor, Chief Technology Officer @ Team Iron
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen