Verwenden des JSON-Objekts als Cache-Daten

JSON ist ein leichtgewichtiges Datenaustauschformat, das strukturierte Daten als Name-Wert-Paare darstellt. Es wurde von Microsoft entwickelt. Windows.Data.Json.JsonObject bietet einen wörterbuchähnlichen JSON-Container, der zum Erstellen, Ändern, Parsen und Stringifizieren von JSON-Daten in einer .NET-Anwendung verwendet werden kann.

Mit NCacheEin JSON-Objekt kann als anwendungsseitiger JSON-Datensatz verwendet werden. Bevor es dem Cache hinzugefügt wird, muss es mithilfe von [hier fehlende Information] in seine String-Darstellung konvertiert werden. Stringify()Die JSON-Zeichenkette wird dann gespeichert in NCache gegen einen eindeutigen Cache-Schlüssel. Dieser Schlüssel wird verwendet, um die zwischengespeicherten JSON-Daten abzurufen, zu aktualisieren oder zu löschen. Nach dem Abrufen des zwischengespeicherten Werts wird dieser als Zeichenkette abgerufen und das JSON-Objekt mithilfe von JsonObject.Parse() or JsonObject.TryParse()Nach der Rekonstruktion können Sie auf JSON-Eigenschaften mithilfe typisierter APIs wie beispielsweise … zugreifen. GetNamedString(), GetNamedNumber(), GetNamedBoolean() und GetNamedObject().

Windows.Data.Json.JsonObject unterstützt Standard-JSON-Werttypen wie:

  • Schnur
  • Nummer
  • Boolean
  • Betreff
  • Feld
  • Null
Wichtig

Windows.Data.Json.JsonObject ist ein anwendungsseitiges JSON-Objekt und ist nicht dasselbe wie NCacheDas JSON-Objektmodell von . Für optimale Kompatibilität speichern Sie es in NCache als JSON-Zeichenkette und rekonstruieren Sie diese nach dem Abruf.

Voraussetzungen:

  • Installieren Sie das Alachisoft.NCache.SDK NuGet-Paket in Ihrer Anwendung.
  • Stellen Sie sicher, dass Ihre Anwendung auf die Windows Runtime-APIs zugreifen kann, weil Windows.Data.Json.JsonObject gehört der Windows.Data.Json Namespace.
  • Nehmen Sie die folgenden Namespaces in Ihre Anwendung auf:
    • Alachisoft.NCache.Client
    • Alachisoft.NCache.Runtime.Exceptions
    • Windows.Data.Json
  • Cache muss laufen.
  • Der Antrag muss mit dem Cache verbunden bevor Sie die Operation durchführen.
  • Der Wert, der hinzugefügt wird NCache muss serialisierbar sein.
  • Für NCache API-Details siehe: ICache, Insert, Erhalten Sie , Entfernen, CacheManager und GetCache.
Hinweis

Bei diesem Ansatz, Windows.Data.Json.JsonObject wird als anwendungsseitiges JSON-Objekt verwendet. Bevor es gespeichert wird in NCache, wandeln Sie es in eine JSON-Zeichenkette um.

Da der zwischengespeicherte Wert eine Zeichenkette ist, NCache Einzelne JSON-Eigenschaften werden nicht automatisch indiziert. Das Hinzufügen einer regulären JSON-Eigenschaft wie z. B. "Type" Es speichert lediglich Typinformationen als Teil der JSON-Daten; es registriert das Element nicht als Typ. NCache JSON-indexierter Typ. Falls indizierte Abfragen über Objektfelder erforderlich sind, speichern Sie ein stark typisiertes Objekt und konfigurieren Sie es entsprechend. NCache Indizes für diesen Typ.

So fügen Sie ein JSON-Objekt zum Cache hinzu

Beim Hinzufügen von JSON-Daten zu NCacheErstellen Sie in der Clientanwendung ein JSON-Objekt und speichern Sie es unter einem eindeutigen Cache-Schlüssel. Dieser Schlüssel wird später verwendet, um die zwischengespeicherten Daten abzurufen, zu aktualisieren oder zu löschen. In .NET erstellen Sie ein Windows.Data.Json.JsonObjectFüllen Sie es mit den erforderlichen Eigenschaften und konvertieren Sie es mithilfe von Stringify()und füge die Zeichenkette hinzu zu NCache Verwendung der Add Methode.

Eigenschaften werden mithilfe der SetNamedValue() Methode, bei der Sie den Eigenschaftsnamen und seinen Wert als IJsonValueDer Eigenschaftsname unterscheidet Groß- und Kleinschreibung. JsonValue.CreateStringValue(), JsonValue.CreateNumberValue(), JsonValue.CreateBooleanValue()oder einen anderen kompatiblen JSON-Werttyp, abhängig von den zu speichernden Daten.

Das folgende Beispiel erstellt ein JSON-Objekt für ein Kundewandelt es in eine JSON-Zeichenkette um und fügt es hinzu zu NCache Verwendung der Add Methode.

try
{
    // Pre-Condition: Cache is already connected
    string cacheName  = "demoCache"; 

    // Obtain an instance of the cache using the provided cache name
    ICache cache = CacheManager.GetCache(cacheName);

    // Assume customer is an instance of the Customer class

    // Create a unique key
    string customerKey = "Customer:ALFKI";

    // Create a new JSON object and set properties
    JsonObject jsonCustomer = new JsonObject();

    jsonCustomer.SetNamedValue("CustomerID", JsonValue.CreateStringValue(customer.CustomerID));
    jsonCustomer.SetNamedValue("ContactName", JsonValue.CreateStringValue(customer.ContactName));
    jsonCustomer.SetNamedValue("CompanyName", JsonValue.CreateStringValue(customer.CompanyName));

    // Convert the JSON object to its string representation
    string jsonCustomerString = jsonCustomer.Stringify();

    // Add the JSON string to the cache
    cache.Add(customerKey, jsonCustomerString);

    Console.WriteLine($"Customer with key '{customerKey}' has been added.");
    Console.WriteLine(jsonCustomerString);
}
catch (OperationFailedException ex)
{
    // Exception can occur due to:
    // Connection Failures
    // Operation Timeout
    // Operation performed during state transfer
}
catch (Exception ex)
{
    // Any generic exception like ArgumentNullException or ArgumentException
}
Hinweis

Um sicherzustellen, dass der Vorgang ausfallsicher ist, wird empfohlen, alle potenziellen Ausnahmen in Ihrer Anwendung zu behandeln, wie in erläutert Umgang mit Fehlern.

JSON-Objekt aus JSON-Zeichenfolge zum Cache hinzufügen

Sie können auch ein JSON-Objekt erstellen, indem Sie eine vorhandene JSON-Zeichenfolge analysieren. JsonObject.Parse() wenn bekannt ist, dass die JSON-Zeichenfolge gültig ist, oder JsonObject.TryParse() wenn die JSON-Zeichenkette ungültig sein könnte. Nachdem die JSON-Zeichenkette analysiert wurde, speichern Sie ihre Zeichenkettenrepräsentation in NCache gegen einen eindeutigen Cache-Schlüssel.

...

// Create a unique key
string customerKey = "Customer:ALFKI";

// JSON string representing customer data
string jsonString = @"{
    ""CustomerID"": ""ALFKI"",
    ""ContactName"": ""Maria Anders"",
    ""CompanyName"": ""Alfreds Futterkiste""
}";

// Parse the JSON string into a JsonObject
if (JsonObject.TryParse(jsonString, out JsonObject jsonCustomer))
{
    // Store the JSON representation in NCache
    cache.Add(customerKey, jsonCustomer.Stringify());

    Console.WriteLine($"Customer with key '{customerKey}' has been added.");
}
else
{
    Console.WriteLine("The provided JSON string is not valid.");
}
...

Wie man ein JSON-Objekt aus dem Cache abruft

Um ein JSON-Objekt abzurufen NCacheRufen Sie den zwischengespeicherten Wert als Zeichenkette mithilfe des Cache-Schlüssels ab. Da der Windows.Data.Json.JsonObject wurde als JSON-String gespeichert, parsen Sie den abgerufenen String wieder in ein JsonObject bevor auf seine Eigenschaften zugegriffen wird.

Das folgende Beispiel ruft eine zwischengespeicherte JSON-Zeichenfolge für ein Kunde, zerlegt es in ein JsonObjectund liest ausgewählte Kundeneigenschaften.

...

// Create a unique key
string customerKey = "Customer:ALFKI";

// Retrieve the JSON string from cache
string cachedJson = cache.Get<string>(customerKey);

Console.WriteLine("Retrieved from cache:");
Console.WriteLine(cachedJson);

if (!string.IsNullOrEmpty(cachedJson) &&
    JsonObject.TryParse(cachedJson, out JsonObject retrievedCustomer))
{
    string customerId = retrievedCustomer.GetNamedString("CustomerID", string.Empty);
    string contactName = retrievedCustomer.GetNamedString("ContactName", string.Empty);
    string companyName = retrievedCustomer.GetNamedString("CompanyName", string.Empty);

    Console.WriteLine("Parsed JSON object successfully.");
    Console.WriteLine($"Customer ID: {customerId}");
    Console.WriteLine($"Contact Name: {contactName}");
    Console.WriteLine($"Company Name: {companyName}");
}
else
{
    Console.WriteLine("Cached JSON could not be retrieved or parsed.");
}
...

Wie man JSON-Daten als benutzerdefiniertes Objekt abruft

Wenn eine Windows.Data.Json.JsonObject Wird gespeichert NCache Da es sich um eine JSON-Zeichenkette handelt, wird sie aus dem Cache abgerufen. Um die zwischengespeicherten JSON-Daten als benutzerdefiniertes Objekt zu verwenden, muss die abgerufene Zeichenkette in ein Objekt geparst werden. JsonObject und ordnen Sie die JSON-Eigenschaften Ihrer benutzerdefinierten Klasse zu.

Die empfohlene Vorgehensweise ist:

  1. Rufen Sie die JSON-Zeichenfolge ab von NCache.
  2. Zerlege es in ein Windows.Data.Json.JsonObject.
  3. Ordnen Sie die JSON-Eigenschaften Ihrem benutzerdefinierten Objekt zu.

Das folgende Beispiel ruft Kundendaten im JSON-Format aus dem Cache ab und ordnet sie einem bestimmten Typ zu. Durch den Objekt.

...

// Create a unique key
string customerKey = "Customer:ALFKI";

// Retrieve the JSON string from cache
string jsonForCustomerMapping = cache.Get<string>(customerKey);

if (!string.IsNullOrEmpty(jsonForCustomerMapping) &&
    JsonObject.TryParse(jsonForCustomerMapping, out JsonObject jsonForCustomer))
{
    Customer mappedCustomer = new Customer
    {
        CustomerID = jsonForCustomer.GetNamedString("CustomerID", string.Empty),
        ContactName = jsonForCustomer.GetNamedString("ContactName", string.Empty),
        CompanyName = jsonForCustomer.GetNamedString("CompanyName", string.Empty)
    };

    // Perform operations according to business logic
    Console.WriteLine("Mapped customer object:");
    Console.WriteLine(mappedCustomer);
    Console.WriteLine($"Company Name: {mappedCustomer.CompanyName}");
}
else
{
    Console.WriteLine("Could not map JSON to Customer object.");
}
...

So aktualisieren Sie ein JSON-Objekt im Cache

NCache Ermöglicht das Aktualisieren zwischengespeicherter Daten durch Abrufen, Ändern und erneutes Einfügen des Elements mit demselben Schlüssel. Bei Verwendung Windows.Data.Json.JsonObject, die zwischengespeicherten JSON-Daten als Zeichenkette abrufen, in ein JSON-Objekt parsen, die erforderlichen Eigenschaften aktualisieren, sie anschließend wieder in eine Zeichenkette umwandeln Stringify()und fügen Sie es wieder in den Cache ein.

Das folgende Beispiel aktualisiert die CompanyName Eigenschaft eines zwischengespeicherten Kunde und fügt ein UpdatedBy Eigenschaft zu den JSON-Daten.

...

// Create a unique key
string customerKey = "Customer:ALFKI";

// Retrieve the JSON string from cache
string jsonToUpdate = cache.Get<string>(customerKey);

if (!string.IsNullOrEmpty(jsonToUpdate) &&
    JsonObject.TryParse(jsonToUpdate, out JsonObject jsonCustomerToUpdate))
{
    // Update an existing property
    jsonCustomerToUpdate.SetNamedValue(
        "CompanyName",
        JsonValue.CreateStringValue("Alachisoft")
    );

    // Add a new property
    jsonCustomerToUpdate.SetNamedValue(
        "UpdatedBy",
        JsonValue.CreateStringValue("Windows.Data.Json")
    );

    // Insert with the same key to update the existing cached value
    cache.Insert(customerKey, jsonCustomerToUpdate.Stringify());

    Console.WriteLine($"Customer with key '{customerKey}' has been updated.");
    Console.WriteLine(jsonCustomerToUpdate.Stringify());
}
else
{
    Console.WriteLine("Could not update because cached JSON was missing or invalid.");
}
...
Hinweis

SetNamedValue() Die Eigenschaft wird eingefügt, falls sie noch nicht existiert, und aktualisiert, falls sie bereits existiert. Daher werden durch das erneute Einfügen der JSON-Zeichenfolge mit demselben Cache-Schlüssel die zwischengespeicherten JSON-Daten aktualisiert.

Wie man ein JSON-Objekt aus dem Cache entfernt

Da das JSON-Objekt gespeichert ist in NCache Als JSON-Zeichenfolge kann sie auf die gleiche Weise wie jedes andere zwischengespeicherte Element aus dem Cache entfernt werden. Geben Sie den Cache-Schlüssel an und rufen Sie die entsprechende Funktion auf. Remove Methode.

Das folgende Beispiel entfernt die zwischengespeicherte JSON-Zeichenfolge aus NCache.

...

// Specify the customer key
string customerKey = "Customer:ALFKI";

// Remove the cached JSON string from NCache
cache.Remove(customerKey);

Console.WriteLine("Cached item removed.");

...
Hinweis

Falls Sie die JSON-Daten vor dem Löschen überprüfen müssen, rufen Sie sie mit folgendem Befehl ab: Get vor dem Anruf Remove.

Weitere Informationen

NCache bietet eine Beispielanwendung für Cache-Daten als JSON auf GitHub.

Siehe auch

Cache-Operationen