Die Zwischenspeicherung ist eine grundlegende Technik in der Softwareentwicklung zur Verbesserung der Leistung durch Speicherung häufig abgerufener Daten im Arbeitsspeicher oder einem schnelleren Speichermedium. In C#, LazyCache ist eine beliebte Bibliothek, die die thread-sichere Cache-Implementierung vereinfacht und es den Entwicklern erleichtert, das Caching in ihren Anwendungen für Szenarien mit hoher Last effektiv zu nutzen.

Was ist LazyCache?

LazyCache ist eine zugrunde liegende Caching-Provider-Bibliothek für .NET/ ASP.NET Core-Anwendungen, die eine einfache und intuitive API für das Caching von Daten bietet. Es ist als NuGet-Paket verfügbar und kann leicht in C#-Projekte integriert werden. Das primäre Ziel von LazyCache ist die Vereinfachung der Cache-Implementierung und die Reduzierung des Boilerplate-Codes, der für die Verwaltung der zwischengespeicherten Informationen unter Verwendung des Double-Locking-Cache-Musters erforderlich ist.

Die wichtigsten Merkmale von LazyCache:

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

2. Automatisches Verfallen: LazyCache unterstützt das automatische Verfallen von zwischengespeicherten Objekten basierend auf konfigurierbaren Verfallsrichtlinien. Entwickler können die Verfallsdauer für zwischengespeicherte Elemente festlegen, und LazyCache entfernt abgelaufene Elemente aus den Cache-Daten.

3. In-Memory Caching: LazyCache speichert zwischengespeicherte Elemente standardmäßig im Arbeitsspeicher, was es für Szenarien geeignet macht, in denen ein schneller Zugriff auf zwischengespeicherte Daten erforderlich ist. Das In-Memory-Caching sorgt für niedrige Latenzzeiten und einen hohen Durchsatz beim Zugriff auf zwischengespeicherte Daten.

4. Thread-sichere Operationen: LazyCache bietet Thread-sichere Operationen für das Hinzufügen, Abrufen und Entfernen von zwischengespeicherten Elementen. Dadurch wird sichergestellt, dass mehrere Threads gleichzeitig auf den Cache zugreifen können, ohne dass das Risiko einer Datenbeschädigung oder -inkonsistenz besteht.

5. Erweiterbarkeit: LazyCache ist so konzipiert, dass es erweiterbar ist und es Entwicklern ermöglicht, das Caching-Verhalten entsprechend ihrer spezifischen Anforderungen anzupassen. Es bietet Hooks für die 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 der intuitiven API sehr einfach. Nachfolgend ein einfaches Beispiel, das zeigt, wie LazyCache verwendet werden kann, um das Ergebnis eines Methodenaufrufs zwischenzuspeichern:

using LazyCache;
public class DataService
{
// private readonly IAppCache cache
    private readonly IAppCache _cache;
    public DataService(IAppCache cache)
    {
        _cache = cache;
    }
    public string GetData()
    {
        return _cache.GetOrAdd("dataKey", () =>
        {
            // Simulate expensive operation such as database calls
            return FetchDataFromDatabase();
        });
    }
    private string FetchDataFromDatabase()
    {
        // Simulate fetching data from a database
        return "Cached Data";
    }
}

using LazyCache;
public class DataService
{
// private readonly IAppCache cache
    private readonly IAppCache _cache;
    public DataService(IAppCache cache)
    {
        _cache = cache;
    }
    public string GetData()
    {
        return _cache.GetOrAdd("dataKey", () =>
        {
            // Simulate expensive operation such as database calls
            return FetchDataFromDatabase();
        });
    }
    private string FetchDataFromDatabase()
    {
        // Simulate fetching data from a database
        return "Cached Data";
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

In diesem Beispiel verwendet die DataService-Klasse LazyCache zum Zwischenspeichern des Ergebnisses der GetData() methode. Die Funktion GetOrAdd() methode ruft die zwischengespeicherten Daten ab, die mit dem angegebenen Schlüssel verbunden sind ("dataKey") wenn sie existiert. Wenn die Daten nicht zwischengespeichert werden, wird der bereitgestellte Delegat (FetchDataFromDatabase()) ausgeführt, um die Daten abzurufen, die dann zur späteren Verwendung zwischengespeichert werden.

Einführung in IronPDF

IronPDF ist eine leistungsstarke C#-PDF-Bibliothek, die es ermöglicht, in .NET-Projekten Inhalte aus PDF-Dokumenten zu erzeugen, zu bearbeiten und zu extrahieren. Hier sind einige der wichtigsten Merkmale:

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.
   • Generieren Sie PDFs aus URLs, HTML-Dateien oder HTML-Strings.

2. Bild- und Inhaltskonvertierung:

   • Konvertieren Sie Bilder in und aus PDF.

   • Extrahieren Sie Text und Bilder aus vorhandenen PDF-Dateien.
   • Unterstützung für verschiedene Bildformate.

3. Bearbeitung und Manipulation:

   • Legen Sie Eigenschaften, Sicherheit und Berechtigungen für PDFs fest.

   • Digitale Signaturen hinzufügen.
   • Bearbeiten Sie die Metadaten und den Revisionsverlauf.

4. Plattformübergreifende Unterstützung:

   • Arbeitet 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.
   • Verfügbar über NuGet für eine einfache Installation.

PDF-Dokument mit IronPDF und LazyCache generieren

Erstellen Sie zunächst eine Konsolenanwendung mit Visual Studio (siehe unten).

Geben Sie den Projektnamen an.

Geben Sie die .NET-Version an.

Installieren Sie das IronPDF-Paket.

Installieren Sie das LazyCache-Paket, um gecachte Methodenaufrufe hinzuzufügen.

using LazyCache;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CodeSample
{
    internal class LazyCacheDemo
    {
        public static void Execute()
        {
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo LazyCache and IronPDF</h1>";
            content += "<h2>Create CachingService</h2>";
            // Create the cache service using caching logic
            IAppCache cache = new CachingService();
            content += "<p>IAppCache cache = new CachingService();</p>";
            var cacheKey = "uniqueKey";           
            content += "<p>string cachedValue = cache.GetOrAdd(cacheKey, expensiveMethod);</p>";
            // Define a factory method to generate the cacheable data
            Func<string> expensiveLongRunMethod = () => {
                var pdf = renderer.RenderHtmlAsPdf(content);
                // Export to a file or Stream
                pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf");
                return content;
            };
            // Get the cached value or add it if it doesn't exist
            string cachedValue = cache.GetOrAdd(cacheKey, expensiveLongRunMethod);
            Console.WriteLine(cachedValue);
        }
    }
}

using LazyCache;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace CodeSample
{
    internal class LazyCacheDemo
    {
        public static void Execute()
        {
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo LazyCache and IronPDF</h1>";
            content += "<h2>Create CachingService</h2>";
            // Create the cache service using caching logic
            IAppCache cache = new CachingService();
            content += "<p>IAppCache cache = new CachingService();</p>";
            var cacheKey = "uniqueKey";           
            content += "<p>string cachedValue = cache.GetOrAdd(cacheKey, expensiveMethod);</p>";
            // Define a factory method to generate the cacheable data
            Func<string> expensiveLongRunMethod = () => {
                var pdf = renderer.RenderHtmlAsPdf(content);
                // Export to a file or Stream
                pdf.SaveAs("AwesomeLazyCacheAndIronPdf.pdf");
                return content;
            };
            // Get the cached value or add it if it doesn't exist
            string cachedValue = cache.GetOrAdd(cacheKey, expensiveLongRunMethod);
            Console.WriteLine(cachedValue);
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Code Erläuterung

• Renderer instanziieren: Eine Instanz von ChromePdfRenderer wird erstellt, um die Konvertierung von HTML-Inhalten in das PDF-Format durchzuführen.
• Inhalt definieren: HTML-Inhalt ("

  Demo LazyCache und IronPDF

  ", "

  Erstelle CachingService

  ", usw.) vorbereitet ist. Dieser Inhalt wird in ein PDF-Dokument umgewandelt und zur Wiederverwendung zwischengespeichert.
• Cache-Dienst erstellen: Ein Caching-Dienst (IAppCache) wird mit dem CachingService von LazyCache instanziiert. Dieser LazyCache-Dienst verwaltet die Speicherung und den Abruf von zwischengespeicherten Daten.
• Cache-Schlüssel: Ein eindeutiger Bezeichner ("uniqueKey") wird zugewiesen, um den zwischengespeicherten PDF-Inhalt darzustellen.
• Define Expensive Method: Eine Fabrikmethode (expensiveLongRunMethod) wird definiert, um die zwischenspeicherfähigen Daten zu erzeugen. Diese Methode ruft den ChromePdfRenderer auf, um HTML-Inhalte als PDF zu rendern. Die resultierende PDF-Datei wird dann gespeichert und als Zeichenkette zurückgegeben.
• Get oder Add to Cache: Die Methode GetOrAdd des Dienstes wird aufgerufen, um den mit dem CacheKey verknüpften Cache-Wert abzurufen. Wenn der Wert nicht im Cache vorhanden ist, wird die Methode 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 der Konsole ausgegeben (Console.WriteLine(cachedValue))die den Abruf von zwischengespeicherten Daten demonstrieren.

Ausgabe

PDF

IronPDF-Lizenzierung (Testversion verfügbar)

Das IronPDF-Paket erfordert eine Lizenz zum Ausführen und Erzeugen der PDF-Datei. Fügen Sie den folgenden Code am Anfang der Anwendung ein, bevor auf das Paket zugegriffen wird.

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Testlizenz ist verfügbar hier.

Schlussfolgerung

LazyCache vereinfacht die Caching-Implementierung in C#-Anwendungen, indem es eine unkomplizierte API und ein automatisches Verfallsdatum für zwischengespeicherte Elemente bietet. Durch die Integration von LazyCache in Ihre Projekte können Sie die Leistung verbessern, indem Sie häufig aufgerufene Daten effizient zwischenspeichern, Latenzzeiten reduzieren und die Ressourcennutzung auf atomare und ordentliche Weise optimieren. Egal, ob Sie Webanwendungen, APIs oder Dienste erstellen, LazyCache kann ein wertvolles Werkzeug sein, um die Leistung und Skalierbarkeit Ihrer C#-Anwendungen zu verbessern.

IronPDF hingegen zeichnet sich als leistungsfähige und vielseitige C#-Bibliothek für die Verarbeitung von PDF-Dokumenten in .NET-Anwendungen aus. Seine robusten Funktionen umfassen das Erstellen, Bearbeiten, Rendern von HTML in PDF und die programmatische Bearbeitung von PDFs. IronPDF bietet Funktionen für die sichere Handhabung von Dokumenten durch Verschlüsselung und digitale Signaturen und ermöglicht es Entwicklern, PDF-Workflows effizient zu verwalten und anzupassen, was es zu einem wertvollen Werkzeug für eine breite Palette von Dokumentenmanagement- und -erstellungsaufgaben in der C#-Entwicklung macht.