Írás közvetlenül a tárolóba

A KÖVETKEZŐKRE VONATKOZIK: SDK v4

A köztes szoftver vagy a környezetobjektum használata nélkül közvetlenül is olvashat és írhat a tárolóobjektumba. Ez megfelelő lehet a robot által a beszélgetések megőrzéséhez használt adatokhoz, illetve a robot beszélgetési folyamatán kívüli forrásból származó adatokhoz. Ebben az adattárolási modellben az adatok közvetlenül a tárolóból olvasnak be állapotkezelő helyett. A cikkben szereplő példakódok bemutatják, hogyan olvashat és írhat adatokat a tárolóba memória, Cosmos DB, Azure Blob és Azure Blob átirattároló használatával.

Megjegyzés:

A Bot Framework JavaScript, C# és Python SDK-k továbbra is támogatottak lesznek, a Java SDK-t azonban 2023 novemberében végső hosszú távú támogatással kivonják. Csak az adattáron belüli kritikus biztonsági és hibajavítások lesznek végrehajtva.

A Java SDK-val létrehozott meglévő robotok továbbra is működni fognak.

Új robotépítéshez fontolja meg a Power Virtual Agents használatát, és olvassa el a megfelelő csevegőrobot-megoldás kiválasztását.

További információ: A robotépítés jövője.

Előfeltételek

• Ha még nincs Azure-előfizetése, kezdés előtt hozzon létre egy ingyenes fiókot.
• A robot helyi létrehozásának ismerete.
• Bot Framework SDK v4-sablonok Visual Studióhoz (C#), Node.js-hez vagy Yeomanhoz.

Megjegyzés:

A sablonokat a Visual Studióban telepítheti.

1. A menüben válassza a Bővítmények , majd a Bővítmények kezelése lehetőséget.
2. A Bővítmények kezelése párbeszédpanelen keresse meg és telepítse a Bot Framework v4 SDK-sablonokat a Visual Studióhoz.

A .NET-robotok Azure-ban való üzembe helyezésével kapcsolatos információkért tekintse meg a robotok üzembe helyezésének és közzétételének módját.

A minta ismertetése

A cikkben szereplő mintakód egy alapszintű echorobot szerkezetével kezdődik, majd további kód hozzáadásával bővíti a robot funkcióit (alább). Ez a kiterjesztett kód létrehoz egy listát a felhasználói bemenetek fogadásának megőrzéséhez. Minden egyes sor, a memóriába mentett felhasználói bemenetek teljes listája visszakerül a felhasználóra. A bemenetek listáját tartalmazó adatszerkezet ezután módosul a tárolóba való mentéshez. A mintakód további funkciókkal bővíti a tárterület különböző típusait.

Memóriatároló

A Bot Framework SDK lehetővé teszi a felhasználói bemenetek memórián belüli tárolását. Mivel a memóriabeli tárolás minden alkalommal törlődik, amikor a robot újraindul, a legjobban tesztelési célokra alkalmas, és nem éles használatra készült. Az állandó tárolótípusok, például az adatbázis-tárolók az éles robotok számára a legjobbak.

Alapszintű robot létrehozása

A témakör többi része egy Echo-robotból épül fel. Az Echo-robot mintakódja helyileg is létrehozható a robot létrehozásához szükséges rövid útmutatók követésével.

C#

Cserélje le a kódot az EchoBot.cs fájlban a következő kódra:

using System;
using System.Threading.Tasks;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

// Represents a bot saves and echoes back user input.
public class EchoBot : ActivityHandler
{
   // Create local Memory Storage.
   private static readonly MemoryStorage _myStorage = new MemoryStorage();

   // Create cancellation token (used by Async Write operation).
   public CancellationToken cancellationToken { get; private set; }

   // Class for storing a log of utterances (text of messages) as a list.
   public class UtteranceLog : IStoreItem
   {
      // A list of things that users have said to the bot
      public List<string> UtteranceList { get; } = new List<string>();

      // The number of conversational turns that have occurred
      public int TurnNumber { get; set; } = 0;

      // Create concurrency control where this is used.
      public string ETag { get; set; } = "*";
   }

   // Echo back user input.
   protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
   {
      // preserve user input.
      var utterance = turnContext.Activity.Text;

      // Make empty local log-items list.
      UtteranceLog logItems = null;

      // See if there are previous messages saved in storage.
      try
      {
         string[] utteranceList = { "UtteranceLog" };
         logItems = _myStorage.ReadAsync<UtteranceLog>(utteranceList).Result?.FirstOrDefault().Value;
      }
      catch
      {
         // Inform the user an error occurred.
         await turnContext.SendActivityAsync("Sorry, something went wrong reading your stored messages!");
      }

      // If no stored messages were found, create and store a new entry.
      if (logItems is null)
      {
         // Add the current utterance to a new object.
         logItems = new UtteranceLog();
         logItems.UtteranceList.Add(utterance);

         // Set initial turn counter to 1.
         logItems.TurnNumber++;

         // Show user new user message.
         await turnContext.SendActivityAsync($"{logItems.TurnNumber}: The list is now: {string.Join(", ", logItems.UtteranceList)}");

         // Create dictionary object to hold received user messages.
         var changes = new Dictionary<string, object>();
         {
            changes.Add("UtteranceLog", logItems);
         }
         try
         {
            // Save the user message to your Storage.
            await _myStorage.WriteAsync(changes, cancellationToken);
         }
         catch
         {
            // Inform the user an error occurred.
            await turnContext.SendActivityAsync("Sorry, something went wrong storing your message!");
         }
      }
      // Else, our storage already contained saved user messages, add new one to the list.
      else
      {
         // add new message to list of messages to display.
         logItems.UtteranceList.Add(utterance);
         // increment turn counter.
         logItems.TurnNumber++;

         // show user new list of saved messages.
         await turnContext.SendActivityAsync($"{logItems.TurnNumber}: The list is now: {string.Join(", ", logItems.UtteranceList)}");

         // Create Dictionary object to hold new list of messages.
         var changes = new Dictionary<string, object>();
         {
            changes.Add("UtteranceLog", logItems);
         };

         try
         {
            // Save new list to your Storage.
            await _myStorage.WriteAsync(changes,cancellationToken);
         }
         catch
         {
            // Inform the user an error occurred.
            await turnContext.SendActivityAsync("Sorry, something went wrong storing your message!");
         }
      }
   }
}

JavaScript

Az .env konfigurációs fájl használatához a robotnak további csomagra van szüksége. Ha még nincs telepítve, kérje le a .NET-csomagot az npm-ből:

npm install --save dotenv

Módosítsa a fő párbeszédpanelt létrehozó index.js kódját. A fő párbeszédpanel const myBot = new EchoBot();létrehozásához meglévő kódsor a tárolóobjektum konstruktornak való átadásának EchoBot engedélyezéséhez szükséges, hogy a felhasználó bemenetét a robot belső memóriájába tárolhassa:

Először fel kell vennie egy hivatkozást a MemoryStorage következőbe botbuilder:

const { MemoryStorage } = require('botbuilder');

Ezután hozza létre a memóriatároló objektumot, és adja át a EchoBot konstruktornak:

const myStorage = new MemoryStorage();
const myBot = new EchoBot(myStorage);

Ez egy MemoryStorage objektumban továbbítja a EchoBot konstruktornak. Ezt később módosítja, hogy átadjon egy Cosmos DB - vagy Blob Storage-objektumot .

Ezután cserélje le a bot.js kódját a következő kódra:

const { ActivityHandler, MemoryStorage } = require('botbuilder');
const restify = require('restify');

// Process incoming requests - adds storage for messages.
class EchoBot extends ActivityHandler {
    constructor(myStorage) {
        super();
        this.storage = myStorage;
        // See https://learn.microsoft.com/azure/bot-service/bot-builder-basics to learn more about the message and other activity types.
        this.onMessage(async turnContext => { console.log('this gets called (message)');
        await turnContext.sendActivity(`You said '${ turnContext.activity.text }'`);
        // Save updated utterance inputs.
        await logMessageText(this.storage, turnContext);
    });
        this.onConversationUpdate(async turnContext => { console.log('this gets called (conversation update)');
        await turnContext.sendActivity('Welcome, enter an item to save to your list.'); });
    }
}

// This function stores new user messages. Creates new utterance log if none exists.
async function logMessageText(storage, turnContext) {
    let utterance = turnContext.activity.text;
    // debugger;
    try {
        // Read from the storage.
        let storeItems = await storage.read(["UtteranceLogJS"])
        // Check the result.
        var UtteranceLogJS = storeItems["UtteranceLogJS"];
        if (typeof (UtteranceLogJS) != 'undefined') {
            // The log exists so we can write to it.
            storeItems["UtteranceLogJS"].turnNumber++;
            storeItems["UtteranceLogJS"].UtteranceList.push(utterance);
            // Gather info for user message.
            var storedString = storeItems.UtteranceLogJS.UtteranceList.toString();
            var numStored = storeItems.UtteranceLogJS.turnNumber;

            try {
                await storage.write(storeItems)
                await turnContext.sendActivity(`${numStored}: The list is now: ${storedString}`);
            } catch (err) {
                await turnContext.sendActivity(`Write failed of UtteranceLogJS: ${err}`);
            }
        }
        else{
            await turnContext.sendActivity(`Creating and saving new utterance log`);
            var turnNumber = 1;
            storeItems["UtteranceLogJS"] = { UtteranceList: [`${utterance}`], "eTag": "*", turnNumber }
            // Gather info for user message.
            var storedString = storeItems.UtteranceLogJS.UtteranceList.toString();
            var numStored = storeItems.UtteranceLogJS.turnNumber;

            try {
                await storage.write(storeItems)
                await turnContext.sendActivity(`${numStored}: The list is now: ${storedString}`);
            } catch (err) {
                await turnContext.sendActivity(`Write failed: ${err}`);
            }
        }
    }
    catch (err){
        await turnContext.sendActivity(`Read rejected. ${err}`);
    }
}

module.exports.EchoBot = EchoBot;

Python

Cserélje le a echo_bot.py kódját a következő kódra:

from botbuilder.core import ActivityHandler, TurnContext, StoreItem, MemoryStorage


class UtteranceLog(StoreItem):
    """
    Class for storing a log of utterances (text of messages) as a list.
    """

    def __init__(self):
        super(UtteranceLog, self).__init__()
        self.utterance_list = []
        self.turn_number = 0
        self.e_tag = "*"


class EchoBot(ActivityHandler):
    """
    Represents a bot saves and echoes back user input.
    """

    def __init__(self):
        self.storage = MemoryStorage()

    async def on_message_activity(self, turn_context: TurnContext):
        utterance = turn_context.activity.text

        # read the state object
        store_items = await self.storage.read(["UtteranceLog"])

        if "UtteranceLog" not in store_items:
            # add the utterance to a new state object.
            utterance_log = UtteranceLog()
            utterance_log.utterance_list.append(utterance)
            utterance_log.turn_number = 1
        else:
            # add new message to list of messages existing state object.
            utterance_log: UtteranceLog = store_items["UtteranceLog"]
            utterance_log.utterance_list.append(utterance)
            utterance_log.turn_number = utterance_log.turn_number + 1

        # Show user list of utterances.
        await turn_context.send_activity(f"{utterance_log.turn_number}: "
                                         f"The list is now: {','.join(utterance_log.utterance_list)}")

        try:
            # Save the user message to your Storage.
            changes = {"UtteranceLog": utterance_log}
            await self.storage.write(changes)
        except Exception as exception:
            # Inform the user an error occurred.
            await turn_context.send_activity("Sorry, something went wrong storing your message!")

A robot indítása

Futtassa helyileg a robotot.

Indítsa el az Emulátort, és csatlakoztassa a robotot

Telepítse a Következő Bot Framework Emulatort , indítsa el az Emulátort, majd csatlakozzon a robothoz az Emulátorban:

1. Válassza az Új robotkonfiguráció létrehozása hivatkozást az Emulator Kezdőlapon .
2. Töltse ki a robothoz való csatlakozáshoz szükséges mezőket a robot indításakor megjelenő weblapon megjelenő információk alapján.

A robot használata

Küldjön üzenetet a robotnak. A robot felsorolja a kapott üzeneteket.

A cikk további része bemutatja, hogyan menthet állandó tárterületre a robot belső memóriája helyett.

A Cosmos DB használata

Fontos

A Cosmos DB tárolási osztály elavult. Az eredetileg a CosmosDbStorage használatával létrehozott tárolóknak nincs partíciókulcs-készlete, és megkapták a _/partitionKey alapértelmezett partíciókulcsát.

A Cosmos DB-tárolóvallétrehozott tárolók particionált Cosmos DB-tárolóval is használhatók. További információért olvassa el a particionálást az Azure Cosmos DB-ben .

Azt is vegye figyelembe, hogy az örökölt Cosmos DB-tárterülettől eltérően a Cosmos DB particionált tároló nem hoz létre automatikusan adatbázist a Cosmos DB-fiókban. Manuálisan kell létrehoznia egy új adatbázist, de hagyja ki manuálisan a tároló létrehozását, mivel a CosmosDbPartitionedStorage létrehozza Önnek a tárolót.

Most, hogy memóriatárolót használt, frissítjük a kódot az Azure Cosmos DB használatára. A Cosmos DB a Microsoft globálisan elosztott, többmodelles adatbázisa. Az Azure Cosmos DB lehetővé teszi, hogy rugalmasan és egymástól függetlenül skálázza az átviteli sebességet és a tárolást az Azure tetszőleges számú földrajzi régiójában. Átviteli sebességet, késést, rendelkezésre állást és konzisztenciát garantál átfogó szolgáltatásiszint-szerződésekkel (SLA-kkal).

Cosmos DB-erőforrás beállítása

A Cosmos DB robotban való használatához létre kell hoznia egy adatbázis-erőforrást, mielőtt a kódba lép. A Cosmos DB-adatbázisok és -alkalmazások létrehozásának részletes leírását a .NET, a Node.js vagy a Python rövid útmutatójában találhatja meg.

Adatbázisfiók létrehozása

1. Lépjen az Azure Portalra, és hozzon létre egy Azure Cosmos DB-fiókot. Keresse meg és válassza az Azure Cosmos DB lehetőséget.

2. Az Azure Cosmos DB lapon válassza az Új lehetőséget az Azure Cosmos DB-fiók létrehozása lap megjelenítéséhez.

   

3. Adja meg az alábbi mezők értékeit:

   1. Előfizetés. Válassza ki az Azure Cosmos-fiókhoz használni kívánt Azure-előfizetést.
   2. Erőforráscsoport. Válasszon ki egy meglévő erőforráscsoportot, vagy válassza az Új létrehozása lehetőséget, és adjon meg egy nevet egy új erőforráscsoportnak.
   3. Fióknév. Adjon meg egy nevet az Azure Cosmos-fiók azonosításához. A rendszer a documents.azure.com utótaggal egészíti ki a megadott nevet az URI létrehozásához, ezért válasszon egyedi nevet. Vegye figyelembe a következő irányelveket:
      • A névnek egyedinek kell lennie az Azure-ban.
      • A névnek 3 és 31 karakter közötti hosszúságúnak kell lennie.
      • A név csak kisbetűket, számokat és kötőjelet (-) tartalmazhat.
   4. API. Core(SQL) kiválasztása
   5. Hely. válassza ki a felhasználókhoz legközelebb eső helyet, hogy a lehető leggyorsabb hozzáférést biztosítsa számukra az adatokhoz.

4. Válassza a Felülvizsgálat és létrehozás lehetőséget.

5. Az ellenőrzés után válassza a Létrehozás lehetőséget.

A fiók létrehozása eltarthat néhány percig. Várjon, amíg a portál megjeleníti a Gratulálunk! Az Azure Cosmos DB-fiók létrehozása lap.

Adatbázis hozzáadása

Megjegyzés:

Ne hozza létre saját maga a tárolót. A robot a belső Cosmos DB-ügyfél létrehozásakor hozza létre, biztosítva, hogy megfelelően legyen konfigurálva a robot állapotának tárolásához.

1. Lépjen az újonnan létrehozott Cosmos DB-fiók Adatkezelő lapjára, majd válassza az Új adatbázis lehetőséget az Új tároló legördülő listából. Ekkor megnyílik egy panel az ablak jobb oldalán, ahol megadhatja az új adatbázis részleteit.

   

2. Adjon meg egy azonosítót az új adatbázishoz, és igény szerint állítsa be az átviteli sebességet (ezt később módosíthatja), és végül válassza az OK gombot az adatbázis létrehozásához. Jegyezze fel ezt az adatbázis-azonosítót, hogy később használhassa a robot konfigurálásakor.

3. Most, hogy létrehozott egy Cosmos DB-fiókot és egy adatbázist, át kell másolnia néhány értéket az új adatbázis robotba való integrálásához. Ezek lekéréséhez lépjen a Cosmos DB-fiók adatbázis-beállítások szakaszában található Kulcsok lapra. Ezen a lapon szüksége lesz az URI-ra (Cosmos DB-végpont) és az ELSŐDLEGES KULCSra (engedélyezési kulcs).

Most már rendelkeznie kell egy Cosmos DB-fiókkal, amely rendelkezik adatbázissal és a robotbeállításokban használható alábbi értékekkel.

• URI
• Elsődleges kulcs
• Adatbázis-azonosító

Cosmos DB konfigurációs adatainak hozzáadása

Használja a cikk előző részében jegyzett részleteket a végpont, az engedélyezési kulcs és az adatbázis-azonosító beállításához. Végül meg kell adnia egy megfelelő nevet annak a tárolónak, amelyet az adatbázison belül hoz létre a robot állapotának tárolásához. Az alábbi példában a létrehozott Cosmos DB-tároló neve "bot-storage".

C#

Adja hozzá a következő adatokat a konfigurációs fájlhoz.

appsettings.json

"CosmosDbEndpoint": "<your-CosmosDb-URI>",
"CosmosDbAuthKey": "<your-primary-key>",
"CosmosDbDatabaseId": "<your-database-id>",
"CosmosDbContainerId": "bot-storage"

JavaScript

Adja hozzá a következő adatokat az .env fájlhoz.

.Env

CosmosDbEndpoint="<your-CosmosDb-URI>"
CosmosDbAuthKey="<your-primary-key>"
CosmosDbDatabaseId="<your-database-id>"
CosmosDbContainerId="bot-storage"

Python

Adja hozzá a következő adatokat a konfigurációs fájlhoz.

config.py

COSMOS_DB_URI="<your-CosmosDb-URI>"
COSMOS_DB_PRIMARY_KEY="your-primary-key"
COSMOS_DB_DATABASE_ID="<your-database-id>"
COSMOS_DB_CONTAINER_ID="bot-storage"

Cosmos DB-csomagok telepítése

Győződjön meg arról, hogy a Cosmos DB-hez szükséges csomagokat használja.

C#

Telepítse a Microsoft.Bot.Builder.Azure NuGet csomagot. További információ a NuGet használatáról: Csomagok telepítése és kezelése a Visual Studióban a NuGet Csomagkezelő használatával.

JavaScript

Adjon hozzá egy hivatkozást a botbuilder-azure-ra az npm használatával.

npm install --save botbuilder-azure

Ha még nincs telepítve, kérje le a .NET-csomagot az npm-ről az .env fájlbeállítások eléréséhez.

npm install --save dotenv

Python

A projektben a botbuilder-azure-ra mutató hivatkozást pip használatával adhat hozzá.

pip install botbuilder-azure

Cosmos DB implementálása

Megjegyzés:

A 4.6-os verzió bevezetett egy új Cosmos DB-tárolószolgáltatót, a Cosmos DB particionált tárolási osztályt, és az eredeti Cosmos DB tárolási osztály elavult. A Cosmos DB-tárolóvallétrehozott tárolók particionált Cosmos DB-tárolóval is használhatók. További információért olvassa el a particionálást az Azure Cosmos DB-ben .

Az örökölt Cosmos DB-tárolótól eltérően a Cosmos DB particionált tároló nem hoz létre automatikusan adatbázist a Cosmos DB-fiókban. Manuálisan kell létrehoznia egy új adatbázist, de hagyja ki manuálisan a tároló létrehozását, mivel a CosmosDbPartitionedStorage létrehozza Önnek a tárolót.

C#

A következő mintakód ugyanazzal a robotkóddal fut, mint a fent megadott memóriatárolási minta, az itt felsorolt kivételekkel. Az alábbi kódrészletek a Cosmos DB storage implementációját mutatják be a "myStorage" számára, amely a helyi memóriatárolót helyettesíti.

Először frissítenie kell a Startup.cs fájlt a robotszerkesztő Azure-kódtárára való hivatkozáshoz:

using Microsoft.Bot.Builder.Azure;

Ezután a ConfigureServices Startup.cs metódusban hozza létre az CosmosDbPartitionedStorage objektumot. Ezt függőséginjektálással továbbítja a EchoBot konstruktornak.

// Use partitioned CosmosDB for storage, instead of in-memory storage.
services.AddSingleton<IStorage>(
    new CosmosDbPartitionedStorage(
        new CosmosDbPartitionedStorageOptions
        {
            CosmosDbEndpoint = Configuration.GetValue<string>("CosmosDbEndpoint"),
            AuthKey = Configuration.GetValue<string>("CosmosDbAuthKey"),
            DatabaseId = Configuration.GetValue<string>("CosmosDbDatabaseId"),
            ContainerId = Configuration.GetValue<string>("CosmosDbContainerId"),
            CompatibilityMode = false,
        }));

Az EchoBot.cs fájlban módosítsa a _myStorage változódeklarációt private static readonly MemoryStorage _myStorage = new MemoryStorage(); a következőre:

// variable used to save user input to CosmosDb Storage.
private readonly IStorage _myStorage;

Ezután adja át az IStorage objektumot a EchoBot konstruktornak:

public EchoBot(IStorage storage)
{
    if (storage is null) throw new ArgumentNullException();
    _myStorage = storage;
}

JavaScript

Először adjon hozzá kódot az index.js fájlhoz, hogy hozzáférhessen a korábban megadott .env fájl értékeihez:

// initialized to access values in .env file.
const ENV_FILE = path.join(__dirname, '.env');
require('dotenv').config({ path: ENV_FILE });

Ezután módosítania kell az index.js-t, hogy a Robot Frameworks belső tároló helyett a Cosmos DB particionált tárolót használja. Az ebben a szakaszban található összes kódmódosítás az index.js fájlban történik.

Először adjon hozzá egy hivatkozást a botbuilder-azure-ra az index.js-ben. Ez hozzáférést biztosít az CosmosDbPartitionedStorage osztályhoz.

const { CosmosDbPartitionedStorage } = require('botbuilder-azure');

Ezután hozzon létre egy új CosmosDbPartitionedStorage objektumot.

const myStorage = new CosmosDbPartitionedStorage({
    cosmosDbEndpoint: process.env.CosmosDbEndpoint,
    authKey: process.env.CosmosDbAuthKey,
    databaseId: process.env.CosmosDbDatabaseId,
    containerId: process.env.CosmosDbContainerId,
    compatibilityMode: false
});

Mostantól megjegyzést fűzhet vagy eltávolíthat a myStorage korábban hozzáadott const deklarációból, mivel a továbbiakban nem a Bot Frameworks belső tárolóba menti a felhasználói bemenetet, hanem a Cosmos DB-be:

//const myStorage = new MemoryStorage();
const myBot = new EchoBot(myStorage);

Python

A következő mintakód ugyanazzal a robotkóddal fut, mint a fent megadott memóriatárolási minta, az itt felsorolt kivételekkel.

A CosmosDBStorage objektum létrehozásához mindkettőre CosmosDbPartitionedStorage szükség CosmosDbPartitionedConfigbotbuilder-azure van.

echo_bot.py

from botbuilder.azure import CosmosDbPartitionedStorage, CosmosDbPartitionedConfig

A config.py beállításainak eléréséhez az alábbiak szerint importálja DefaultConfig az alábbiakat:

from config import DefaultConfig
CONFIG = DefaultConfig()

Megjegyzést fűzhet a Memóriatárolóhoz, __init__ és lecserélheti a Cosmos DB-re való hivatkozásra. Használja a fent használt URI-t (végpontot), elsődleges kulcsot (engedélyezési kulcsot), adatbázis-azonosítót és tárolóazonosítót.

Ezután távolítsa el vagy fűzzön megjegyzést a Memóriatároló kódjához __init__ , és adjon hozzá egy hivatkozást a Cosmos DB-adatokhoz a config.py.

Az alábbi kódrészlet a Cosmos DB "Storage"-hoz készült implementációját mutatja be, amely a helyi memóriatárolót helyettesíti.

echo_bot.py

def __init__(self):
    cosmos_config = CosmosDbPartitionedConfig(
        cosmos_db_endpoint=CONFIG.COSMOS_DB_URI,
        auth_key=CONFIG.COSMOS_DB_PRIMARY_KEY,
        database_id=CONFIG.COSMOS_DB_DATABASE_ID,
        container_id=CONFIG.COSMOS_DB_CONTAINER_ID,
        compatibility_mode = False
    )
    self.storage = CosmosDbPartitionedStorage(cosmos_config)

A Cosmos DB-robot indítása

Futtassa helyileg a robotot.

Cosmos DB-robot tesztelése a Bot Framework Emulator használatával

Indítsa el a Bot Framework Emulatort, és csatlakozzon a robothoz:

1. Válassza az Új robotkonfiguráció létrehozása hivatkozást az Emulator Üdvözlőlapon .
2. Töltse ki a robothoz való csatlakozáshoz szükséges mezőket a robot indításakor megjelenő weblapon megjelenő információk alapján.

A Cosmos DB-robot használata

Küldjön üzenetet a robotnak, és a robot felsorolja a kapott üzeneteket.

Cosmos DB-adatok megtekintése

Miután futtatta a robotot, és mentette az adatokat, megtekintheti az Azure Portalon tárolt adatokat az Adatkezelő lapon.

Blob Storage használata

Az Azure Blob Storage a Microsoft felhőalapú objektumtárolási megoldása. A Blob Storage nagy mennyiségű strukturálatlan adat, például szöveg vagy bináris adatok tárolására van optimalizálva. Ez a szakasz bemutatja, hogyan hozhat létre Azure Blob Storage-fiókot és -tárolót, majd hogyan hivatkozhat a blobtároló tárolójára a robotból.

További információ a Blob Storage-ról: Mi az Az Azure Blob Storage?

Blob Storage-fiók létrehozása

Ha blobtárolót szeretne használni a robotban, be kell állítania néhány dolgot, mielőtt belefogad a kódba.

1. Az Azure Portalon válassza a Minden szolgáltatás elemet.

2. A Minden szolgáltatás lap Kiemelt szakaszában válassza a Tárfiókok lehetőséget.

3. A Tárfiókok lapon válassza az Új lehetőséget.

   

4. Az Előfizetés mezőben válassza ki azt az előfizetést, amelyben létre szeretné hozni a tárfiókot.

5. Az Erőforráscsoport mezőben válasszon ki egy meglévő erőforráscsoportot, vagy válassza az Új létrehozása lehetőséget, és adja meg az új erőforráscsoport nevét.

6. A Tárfiók neve mezőben adja meg a fiók nevét. Vegye figyelembe a következő irányelveket:

   • A névnek egyedinek kell lennie az Azure-ban.
   • A névnek 3 és 24 karakter közötti hosszúságúnak kell lennie.
   • A név csak számokat és kisbetűket tartalmazhat.

7. A Hely mezőben válassza ki a tárfiók helyét, vagy használja az alapértelmezett helyet.

8. A többi beállításnál konfigurálja a következőket:

   • Teljesítmény: Standard. További információ a teljesítményről.
   • Fiók típusa: BlobStorage. További információ a tárfiókokról.
   • Replikáció: Hagyja meg az alapértelmezett beállítást. További információ a redundanciáról.

9. A Tárfiók létrehozása lap Projekt részletei szakaszában válassza ki az előfizetés és az erőforráscsoport kívánt értékeit.

10. A Tárfiók létrehozása lap Példány részletei szakaszában adja meg a Tárfiók nevét, majd válassza ki a Hely, a Fiók típusa és a Replikáció értéket.

11. Válassza a Felülvizsgálat + létrehozás lehetőséget a tárfiók beállításainak áttekintéséhez.

12. Az ellenőrzés után válassza a Létrehozás lehetőséget.

Blob Storage-tároló létrehozása

A Blob Storage-fiók létrehozása után nyissa meg, majd:

1. Válassza a Storage Explorer (előzetes verzió) lehetőséget.

2. Ezután kattintson a jobb gombbal a BLOB-TÁROLÓkra

3. Válassza a Blob-tároló létrehozása lehetőséget a legördülő listából.

   

4. Adjon meg egy nevet az Új tároló űrlapon. Ezt a nevet fogja használni a "blobtároló neve" értékéhez, hogy hozzáférést biztosítson a Blob Storage-fiókhoz. Vegye figyelembe a következő irányelveket:

   • Ez a név csak kisbetűket, számokat és kötőjeleket tartalmazhat.
   • Ennek a névnek betűvel vagy számmal kell kezdődnie.
   • Minden kötőjelet meg kell előznie, és egy érvényes, nem kötőjel karakternek kell követnie.
   • A névnek 3 és 63 karakter közötti hosszúságúnak kell lennie.

Blob Storage konfigurációs adatainak hozzáadása

Keresse meg a Blob Storage robothoz való konfigurálásához szükséges Blob Storage-kulcsokat a fent látható módon:

1. Az Azure Portalon nyissa meg a Blob Storage-fiókot, és válassza az Access-kulcsokat a Gépház szakaszban.
2. Ha úgy szeretné konfigurálni a robotot, hogy hozzáférjen a Blob Storage-fiókjához, használja a Csatlakozás ion sztringet a blob kapcsolati sztring értékeként.

C#

Adja hozzá a következő adatokat a konfigurációs fájlhoz.

appsettings.json

"BlobConnectionString": "<your-blob-connection-string>",
"BlobContainerName": "<your-blob-container-name>",

JavaScript

Adja hozzá a következő adatokat az .env fájlhoz.

.Env

BlobConnectionString="<your-blob-connection-string>"
BlobContainerName="<your-blob-container-name>"

Python

Adja hozzá a következő adatokat a konfigurációs fájlhoz. Használja ugyanazt a tárolónevet és kapcsolati sztring a blobtároló létrehozásakor.

config.py

BLOB_CONNECTION_STRING="<your-blob-connection-string>"
BLOB_CONTAINER_NAME="<your-blob-container-name>"

Blob Storage-csomagok telepítése

Ha korábban nem telepítette, telepítse a következő csomagokat.

C#

Telepítse a Microsoft.Bot.Builder.Azure.Blobs NuGet csomagot. További információ a NuGet használatáról: Csomagok telepítése és kezelése a Visual Studióban a NuGet Csomagkezelő használatával.

JavaScript

Hivatkozásokat botbuilder-azure-blobs adhat hozzá a projekthez npm-en keresztül.

Megjegyzés:

Ez az npm-csomag a Fejlesztőgépen meglévő Python telepítésére támaszkodik. Ha korábban még nem telepítette a Pythont, a Python.org

npm install --save botbuilder-azure-blobs

Ha még nincs telepítve, kérje le a .NET-csomagot az npm-ről az .env fájlbeállítások eléréséhez.

npm install --save dotenv

Python

A projektben a botbuilder-azure-ra mutató hivatkozást pip használatával adhat hozzá.

pip install botbuilder-azure

A Blob Storage implementálása

A Blob Storage a robot állapotának tárolására szolgál.

C#

Megjegyzés:

A 4.10-es Microsoft.Bot.Builder.Azure.AzureBlobStorage verzió elavult. Használja az újat Microsoft.Bot.Builder.Azure.Blobs.BlobsStorage a helyén.

A következő mintakód ugyanazzal a robotkóddal fut, mint a fent megadott memóriatárolási minta, az itt felsorolt kivételekkel.

Az alábbi kódrészletek a "myStorage" Blob Storage implementációját mutatják be, amely felváltja a helyi memóriatárolót.

Először frissítenie kell a Startup.cs fájlt a robotszerkesztő Azure Blobs-kódtárára való hivatkozáshoz:

Startup.cs

using Microsoft.Bot.Builder.Azure.Blobs;

Ezután a ConfigureServices Startup.cs metódusban hozza létre az BlobsStorage objektumot, és adja át a forrás értékeitappsettings.json. Ezt függőséginjektálással továbbítja a EchoBot konstruktornak.

//Use Azure Blob storage, instead of in-memory storage.
services.AddSingleton<IStorage>(
    new BlobsStorage(
        Configuration.GetValue<string>("BlobConnectionString"),
        Configuration.GetValue<string>("BlobContainerName")
        ));

Most először frissítenie kell az EchoBot.cs fájlt, hogy hivatkozzon a robotszerkesztő Azure blobtárára :

EchoBot.cs

using Microsoft.Bot.Builder.Azure.Blobs;

Ezután távolítsa el vagy fűzzön megjegyzést a "private static readonly MemoryStorage _myStorage = new MemoryStorage();" nevű MemoryStorage változót létrehozó kódsorhoz, és hozzon létre egy új változót, amely a felhasználói bemenet blobtárolóba való mentésére szolgál.

EchoBot.cs

// variable used to save user input to CosmosDb Storage.
private readonly IStorage _myStorage;

Ezután adja át az IStorage objektumot a EchoBot konstruktornak:

public EchoBot(IStorage storage)
{
    if (storage is null) throw new ArgumentNullException();
    _myStorage = storage;
}

Miután a tárterület a Blob Storage-fiókra lett állítva, a robot kódja mostantól tárolja és lekéri az adatokat a Blob Storage-ból.

JavaScript

Az ebben a szakaszban található összes kódmódosítás az index.js fájlban történik.

Először adjon hozzá kódot, amely lehetővé teszi a korábban megadott .env fájl értékeinek elérését:

// initialized to access values in .env file.
const ENV_FILE = path.join(__dirname, '.env');
require('dotenv').config({ path: ENV_FILE });

Ezután módosítania kell a Blob Storage-t a Bot Frameworks belső tárolója helyett.

Ezután adjon hozzá egy hivatkozást a következőhöz botbuilder-azure-blobs: Ez hozzáférést biztosít a Blob Storage API-hoz:

const { BlobsStorage } = require("botbuilder-azure-blobs");

Ha módosítani szeretné a kódot az BlobsStorage osztály használatára, módosítsa a deklarációt az myStorage alábbiak szerint:

const myStorage = new BlobsStorage(
    process.env.BlobConnectionString,
    process.env.BlobContainerName
);

Miután a tárterület a Blob Storage-fiókra lett állítva, a robot kódja mostantól tárolja és lekéri az adatokat a Blob Storage-ból.

Python

A következő mintakód ugyanazzal a robotkóddal fut, mint a fent megadott memóriatárolási minta, az itt felsorolt kivételekkel.

Ehhez szükség lesz a következőre BlobStoragebotbuilder-azure: BlobStorageSettings .

echo_bot.py

from botbuilder.azure import BlobStorage, BlobStorageSettings

A config.py beállításainak eléréséhez az alábbiak szerint importálja DefaultConfig az alábbiakat:

from config import DefaultConfig
CONFIG = DefaultConfig()

Ezután távolítsa el vagy fűzzön megjegyzést a memóriatároló kódjához __init__ , és adjon hozzá egy hivatkozást a blobtároló adataira config.py.

Az alábbi kódrészlet a Blob Storage egy olyan implementációját mutatja be, amely a helyi memóriatárolót helyettesíti.

echo_bot.py

def __init__(self):
    blob_settings = BlobStorageSettings(
        connection_string=CONFIG.BLOB_CONNECTION_STRING,
        container_name=CONFIG.BLOB_CONTAINER_NAME
    )
    self.storage = BlobStorage(blob_settings)

Miután a tárterület a Blob Storage-fiókra lett állítva, a robot kódja mostantól tárolja és lekéri az adatokat a Blob Storage-ból.

A Blob Storage-robot indítása

Futtassa helyileg a robotot.

Indítsa el az Emulatort, és csatlakoztassa a Blob Storage-robotot

Ezután indítsa el az Emulátort, majd csatlakozzon a robothoz az Emulátorban:

1. Válassza az Új robotkonfiguráció létrehozása hivatkozást az Emulátor "Üdvözli" lapján.
2. Töltse ki a robothoz való csatlakozáshoz szükséges mezőket a robot indításakor megjelenő weblapon megjelenő információk alapján.

A Blob Storage-robot használata

Küldjön üzenetet a robotnak, és a robot felsorolja a kapott üzeneteket.

Blob Storage-adatok megtekintése

Miután futtatta a robotot, és mentette az adatokat, azOkat az Azure Portal Storage Explorer lapján tekintheti meg.

Blob átirattároló

Az Azure Blob Transcript Storage speciális tárolási lehetőséget biztosít, amellyel egyszerűen mentheti és lekérheti a felhasználói beszélgetéseket rögzített átirat formájában. Az Azure Blob-átiratok tárolása hasznos a felhasználói bemenetek automatikus rögzítéséhez a robot teljesítményének hibakeresése során.

Megjegyzés:

A Python jelenleg nem támogatja az Azure Blob-átiratok tárolását. Bár a JavaScript támogatja a Blob-átiratok tárolását, az alábbi útmutatás csak C# esetén érhető el.

Blob átirattároló beállítása

Az Azure Blob-átirattár a fenti "A Blob Storage-fiók létrehozása" és a "Konfigurációs adatok hozzáadása" című szakasz lépéseit követve használhatja ugyanazt a blobtároló-fiókot, amelyet létrehozott. Most hozzáadunk egy tárolót az átirataink tárolásához

1. Nyissa meg az Azure Blob Storage-fiókját.
2. Válassza a Storage Explorer lehetőséget.
3. Kattintson a jobb gombbal a BLOB-TÁROLÓk elemre, és válassza a Blob-tároló létrehozása lehetőséget.
4. Adja meg az átirattároló nevét, majd kattintson az OK gombra. (Beírtuk a mybottranscripteket)

Blob átirattároló implementálása

Az alábbi kód az átirattár mutatóját _myTranscripts az új Azure Blob-átirat tárfiókhoz köti. Ha ezt a hivatkozást egy új tárolónévvel, <az Ön-blob-transcript-container-name> névvel szeretné létrehozni, létrehoz egy új tárolót a Blob Storage-on belül az átiratfájlok tárolásához.

A Blob-átiratok tárolása robotok átiratainak tárolására szolgál.

Megjegyzés:

A 4.10-es Microsoft.Bot.Builder.Azure.AzureBlobTranscriptStore verzió elavult. Használja az újat Microsoft.Bot.Builder.Azure.Blobs.BlobsTranscriptStore a helyén.

echoBot.cs

using Microsoft.Bot.Builder.Azure.Blobs;

public class EchoBot : ActivityHandler
{
   ...

   private readonly BlobsTranscriptStore _myTranscripts = new BlobsTranscriptStore("<your-azure-storage-connection-string>", "<your-blob-transcript-container-name>");

   ...
}

Felhasználói beszélgetések tárolása Az Azure Blob-átiratokban

Miután egy blobtároló elérhetővé válik az átiratok tárolásához, megkezdheti a felhasználói beszélgetések megőrzését a robottal. Ezek a beszélgetések később hibakeresési eszközként is használhatók annak megtekintéséhez, hogy a felhasználók hogyan használják a robotot. Minden Emulator-újraindítási beszélgetés egy új átiratos beszélgetési lista létrehozását kezdeményezi. Az alábbi kód megőrzi a felhasználói beszélgetések bemeneteit egy tárolt átiratfájlban.

• Az aktuális átirat mentése a következővel történik LogActivityAsync: .
• A mentett átiratok lekérése a következővel történik ListTranscriptsAsync: . Ebben a mintakódban az egyes tárolt átiratok azonosítója egy "storedTranscripts" nevű listába lesz mentve. Ez a lista később a tárolt blobok átiratainak számának kezelésére szolgál.

echoBot.cs

protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    await _myTranscripts.LogActivityAsync(turnContext.Activity);

    List<string> storedTranscripts = new List<string>();
    PagedResult<Microsoft.Bot.Builder.TranscriptInfo> pagedResult = null;
    var pageSize = 0;
    do
    {
       pagedResult = await _myTranscripts.ListTranscriptsAsync("emulator", pagedResult?.ContinuationToken);
       pageSize = pagedResult.Items.Count();

       // transcript item contains ChannelId, Created, Id.
       // save the channelIds found by "ListTranscriptsAsync" to a local list.
       foreach (var item in pagedResult.Items)
       {
          storedTranscripts.Add(item.Id);
       }
    } while (pagedResult.ContinuationToken != null);

    ...
}

Tárolt blobok átiratainak kezelése

Bár a tárolt átiratok hibakeresési eszközként is használhatók, idővel a tárolt átiratok száma nagyobb lehet, mint amennyit meg szeretne őrizni. Az alábbi további kód az összes, az utolsó három lekért átirati elem eltávolítására szolgál DeleteTranscriptAsync a blob átirattárolójából.

echoBot.cs

protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    await _myTranscripts.LogActivityAsync(turnContext.Activity);

    List<string> storedTranscripts = new List<string>();
    PagedResult<Microsoft.Bot.Builder.TranscriptInfo> pagedResult = null;
    var pageSize = 0;
    do
    {
       pagedResult = await _myTranscripts.ListTranscriptsAsync("emulator", pagedResult?.ContinuationToken);
       pageSize = pagedResult.Items.Count();

       // transcript item contains ChannelId, Created, Id.
       // save the channelIds found by "ListTranscriptsAsync" to a local list.
       foreach (var item in pagedResult.Items)
       {
          storedTranscripts.Add(item.Id);
       }
    } while (pagedResult.ContinuationToken != null);

    // Manage the size of your transcript storage.
    for (int i = 0; i < pageSize; i++)
    {
       // Remove older stored transcripts, save just the last three.
       if (i < pageSize - 3)
       {
          string thisTranscriptId = storedTranscripts[i];
          try
          {
             await _myTranscripts.DeleteTranscriptAsync("emulator", thisTranscriptId);
           }
           catch (System.Exception ex)
           {
              await turnContext.SendActivityAsync("Debug Out: DeleteTranscriptAsync had a problem!");
              await turnContext.SendActivityAsync("exception: " + ex.Message);
           }
       }
    }
    ...
}

Az osztályról további információt az Azure Blob Transcript Storage-ban talál.

További információ

Egyidejűség kezelése eTags használatával

A robotkód példájában mindegyik IStoreItem tulajdonságát eTag a következőre *állítjuk be: . Az eTag áruházobjektum (entitáscímke) tagját a Cosmos DB használja az egyidejűség kezelésére. Ez eTag azt jelzi az adatbázisnak, hogy mi a teendő, ha a robot egy másik példánya ugyanabban a tárolóban módosította az objektumot, amelybe a robot ír.

Az utolsó írás nyer – felülírás engedélyezése

A eTag csillag (*) tulajdonságértéke azt jelzi, hogy az utolsó író nyer. Új adattár létrehozásakor beállíthat egy tulajdonságot eTag* , amely jelzi, hogy korábban nem mentette az éppen írt adatokat, vagy azt szeretné, hogy az utolsó író felülírja a korábban mentett tulajdonságokat. Ha az egyidejűség nem jelent problémát a robot számára, a tulajdonság * írása lehetővé teszi a eTag felülírást.

Egyidejűség fenntartása és felülírás megakadályozása

Amikor az adatokat a Cosmos DB-be tárolja, használjon a tulajdonsághoz való egyidejű hozzáféréstől eltérő *eTag értéket, és kerülje a robot egy másik példányának módosításainak felülírását. A robot hibaüzenetet kap az üzenettel etag conflict key= , amikor állapotadatokat próbál menteni, és nem eTag ugyanaz az érték, mint a eTag tárolóban.

Alapértelmezés szerint a Cosmos DB-tároló minden alkalommal ellenőrzi a eTag tárolóobjektum tulajdonságát, hogy a robot minden alkalommal egyenlőséget biztosít-e, amikor egy robot ír az adott elemre, majd minden írás után egy új egyedi értékre frissíti azt. Ha az eTag írási tulajdonság nem egyezik a eTag tárolóban lévő tulajdonságtal, az azt jelenti, hogy egy másik robot vagy szál módosította az adatokat.

Tegyük fel például, hogy azt szeretné, hogy a robot szerkessze a mentett jegyzetet, de nem szeretné, hogy a robot felülírja a robot egy másik példányának módosításait. Ha a robot egy másik példánya végzett módosításokat, azt szeretné, hogy a felhasználó a legújabb frissítésekkel szerkessze a verziót.

C#

Először hozzon létre egy implementálható osztályt IStoreItem.

EchoBot.cs

public class Note : IStoreItem
{
    public string Name { get; set; }
    public string Contents { get; set; }
    public string ETag { get; set; }
}

Ezután hozzon létre egy kezdeti megjegyzést egy tárobjektum létrehozásával, és adja hozzá az objektumot a tárolóhoz.

EchoBot.cs

// create a note for the first time, with a non-null, non-* ETag.
var note = new Note { Name = "Shopping List", Contents = "eggs", ETag = "x" };

var changes = Dictionary<string, object>();
{
    changes.Add("Note", note);
};
await NoteStore.WriteAsync(changes, cancellationToken);

Ezután később érheti el és frissítheti a jegyzetet, megtartva azt eTag , amelyet az áruházból olvas.

EchoBot.cs

var note = NoteStore.ReadAsync<Note>("Note").Result?.FirstOrDefault().Value;

if (note != null)
{
    note.Contents += ", bread";
    var changes = new Dictionary<string, object>();
    {
         changes.Add("Note1", note);
    };
    await NoteStore.WriteAsync(changes, cancellationToken);
}

Ha a megjegyzést a módosítások írása előtt frissítették az áruházban, a hívás kivételt fog eredményezni Write .

JavaScript

Adjon hozzá egy segédfüggvényt a robot végéhez, amely egy mintajegyzetet fog írni egy adattárba. Először hozzon létre myNoteData objektumot.

bot.js

// Helper function for writing a sample note to a data store
async function createSampleNote(storage, context) {
    var myNoteData = {
        name: "Shopping List",
        contents: "eggs",
        // If any Note file is already stored, the eTag field
        // must be set to "*" in order to allow writing without first reading the stored eTag
        // otherwise you'll likely get an exception indicating an eTag conflict.
        eTag: "*"
    }
}

createSampleNote A segédfüggvényen belül inicializáljon egy changes objektumot, és adja hozzá a jegyzeteit, majd írja azt a tárolóba.

bot.js

// Write the note data to the "Note" key
var changes = {};
changes["Note"] = myNoteData;
// Creates a file named Note, if it doesn't already exist.
// specifying eTag= "*" will overwrite any existing contents.
// The act of writing to the file automatically updates the eTag property
// The first time you write to Note, the eTag is changed from *, and file contents will become:
//    {"name":"Shopping List","contents":"eggs","eTag":"1"}
try {
     await storage.write(changes);
     var list = changes["Note"].contents;
     await context.sendActivity(`Successful created a note: ${list}`);
} catch (err) {
     await context.sendActivity(`Could not create note: ${err}`);
}

A segédfüggvény a robot logikájából érhető el a következő hívás hozzáadásával:

bot.js

// Save a note with etag.
await createSampleNote(storage, turnContext);

Miután létrejött, a megjegyzés későbbi lekéréséhez és frissítéséhez létrehozunk egy másik segédfüggvényt, amely akkor érhető el, amikor a felhasználó be van gépelve a "megjegyzés frissítése" szövegbe.

bot.js

async function updateSampleNote(storage, context) {
    try {
        // Read in a note
        var note = await storage.read(["Note"]);
        console.log(`note.eTag=${note["Note"].eTag}\n note=${JSON.stringify(note)}`);
        // update the note that we just read
        note["Note"].contents += ", bread";
        console.log(`Updated note=${JSON.stringify(note)}`);

        try {
             await storage.write(note); // Write the changes back to storage
             var list = note["Note"].contents;
             await context.sendActivity(`Successfully updated note: ${list}`);
        } catch (err) {
             console.log(`Write failed: ${err}`);
        }
    }
    catch (err) {
        await context.sendActivity(`Unable to read the Note: ${err}`);
    }
}

Ez a segédfüggvény a robot logikájából érhető el a következő hívás hozzáadásával:

bot.js

// Update a note with etag.
await updateSampleNote(storage, turnContext);

Ha a megjegyzést egy másik felhasználó frissítette az áruházban, mielőtt megkísérelte volna visszaírni a módosításokat, az eTag érték már nem egyezik, és a hívás kivételt fog eredményezni write .

Python

Először hozzon létre egy implementálható osztályt StoreItem.

echo_bot.py

class Note(StoreItem):
    def __init__(self, name: str, contents: str, e_tag="*"):
        super(Note, self).__init__()
        self.name = name
        self.contents = contents
        self.e_tag = e_tag

Ezután hozzon létre egy kezdeti megjegyzést egy tárobjektum létrehozásával, és adja hozzá az objektumot a tárolóhoz.

echo_bot.py

# create a note for the first time, with a non-null, non-* ETag.
changes = {"Note": Note(name="Shopping List", contents="eggs", e_tag="x")}

await self.storage.write(changes)

Ezután később érheti el és frissítheti a jegyzetet, megtartva azt eTag , amelyet az áruházból olvas.

echo_bot.py

store_items = await self.storage.read(["Note"])
    note = store_items["Note"]
    note.contents = note.contents + ", bread"

    changes = {"Note": note}
    await self.storage.write(changes)

Ha a megjegyzést a módosítások írása előtt frissítették az áruházban, a hívás kivételt fog eredményezni write .

Az egyidejűség fenntartásához mindig olvasson be egy tulajdonságot a tárolóból, majd módosítsa az olvasott tulajdonságot, hogy az eTag megmaradjon. Ha felhasználói adatokat olvas az áruházból, a válasz tartalmazza az eTag tulajdonságot. Ha módosítja az adatokat, és frissített adatokat ír az áruházba, a kérésnek tartalmaznia kell az eTag tulajdonságot, amely ugyanazt az értéket adja meg, mint amelyet korábban olvasott. Ha azonban olyan objektumot ír, amelynek a készlete eTag* lehetővé teszi, hogy az írás felülírja a többi módosítást.

Következő lépések

Most, hogy már tudja, hogyan olvashat és írhat közvetlenül a tárolóból, áttekintheti, hogyan használhatja ezt az állapotkezelőt.

Állapot mentése beszélgetés és felhasználói tulajdonságok használatával