Rechtstreeks naar opslag schrijven

VAN TOEPASSING OP: SDK v4

U kunt rechtstreeks naar uw opslagobject lezen en schrijven zonder middleware of contextobject te gebruiken. Dit kan geschikt zijn voor gegevens die uw bot gebruikt om een gesprek te behouden of gegevens die afkomstig zijn van een bron buiten de gespreksstroom van uw bot. In dit gegevensopslagmodel worden gegevens rechtstreeks vanuit de opslag gelezen in plaats van een statusbeheerder te gebruiken. De codevoorbeelden in dit artikel laten zien hoe u gegevens kunt lezen en schrijven naar opslag met behulp van geheugen, Cosmos DB, Azure Blob en Azure Blob Transcript Storage.

Notitie

De Sdk's voor Bot Framework JavaScript, C# en Python blijven ondersteund, maar de Java SDK wordt buiten gebruik gesteld met definitieve langetermijnondersteuning die eindigt op november 2023.

Bestaande bots die zijn gebouwd met de Java SDK blijven functioneren.

Voor het bouwen van nieuwe bots kunt u Microsoft Copilot Studio gebruiken en lezen over het kiezen van de juiste copilot-oplossing.

Zie De toekomst van botbouw voor meer informatie.

Vereisten

• Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.
• Bekendheid met het lokaal maken van een bot .
• Bot Framework SDK v4-sjablonen voor Visual Studio (C#), Node.js of Yeoman.

Notitie

U kunt de sjablonen installeren vanuit Visual Studio.

1. Selecteer Extensies in het menu en vervolgens Extensies beheren.
2. Zoek en installeer Bot Framework v4 SDK-sjablonen voor Visual Studio in het dialoogvenster Extensies beheren.

Zie hoe u een bot inricht en publiceert voor informatie over het implementeren van .NET-bots in Azure.

Over dit voorbeeld

De voorbeeldcode in dit artikel begint met de structuur van een eenvoudige echobot en breidt vervolgens de functionaliteit van die bot uit door extra code toe te voegen (hieronder). Met deze uitgebreide code wordt een lijst gemaakt om gebruikersinvoer te behouden wanneer ze worden ontvangen. Elke beurt, de volledige lijst met gebruikersinvoer, opgeslagen in het geheugen, wordt weer teruggeklinkt naar de gebruiker. De gegevensstructuur met deze lijst met invoer wordt vervolgens gewijzigd om op te slaan in de opslag. Verschillende typen opslag worden verkend omdat er extra functionaliteit wordt toegevoegd aan deze voorbeeldcode.

Geheugenopslag

Met de Bot Framework SDK kunt u gebruikersinvoer opslaan met behulp van opslag in het geheugen. Omdat opslag in het geheugen wordt gewist telkens wanneer de bot opnieuw wordt opgestart, is deze het meest geschikt voor testdoeleinden en is deze niet bedoeld voor productiegebruik. Permanente opslagtypen, zoals databaseopslag, zijn het meest geschikt voor productiebots.

Een eenvoudige bot bouwen

De rest van dit onderwerp bouwt voort op een Echo-bot. De voorbeeldcode van de Echo-bot kan lokaal worden gebouwd door de quickstart-instructies voor het maken van een bot te volgen.

C#

Vervang de code in EchoBot.cs door de volgende code:

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

Als u het .env-configuratiebestand wilt gebruiken, heeft uw bot een extra pakket nodig. Als dit nog niet is geïnstalleerd, haalt u het .NET-pakket op uit npm:

npm install --save dotenv

Wijzig de code in index.js waarmee het hoofddialoogvenster wordt gemaakt. De bestaande coderegel voor het maken van het hoofddialoogvenster is const myBot = new EchoBot();, moet worden bijgewerkt om het doorgeven van een opslagobject aan de EchoBot constructor mogelijk te maken, zodat u de invoer van de gebruiker kunt opslaan in het interne geheugen van de bot:

Eerst moet u een verwijzing toevoegen naarMemoryStorage:botbuilder

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

Maak vervolgens het geheugenopslagobject en geef het door aan de EchoBot constructor:

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

Hiermee wordt een MemoryStorage object doorgegeven aan de EchoBot constructor. U wijzigt dit later om een Cosmos DB - of Blob Storage-object door te geven.

Vervang vervolgens de code in bot.js door de volgende code:

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

Vervang de code in echo_bot.py door de volgende code:

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!")

Uw bot starten

Voer uw bot lokaal uit.

De emulator starten en uw bot verbinden

Installeer de Bot Framework Emulator Next, start de Emulator en maak vervolgens verbinding met uw bot in de Emulator:

1. Selecteer de koppeling Nieuwe botconfiguratie maken op het tabblad Welkom bij emulator.
2. Vul velden in om verbinding te maken met uw bot, op basis van de informatie op de webpagina die wordt weergegeven toen u de bot startte.

Interactie met uw bot

Verzend een bericht naar uw bot. De bot vermeldt de berichten die de bot heeft ontvangen.

De rest van dit artikel laat zien hoe u kunt opslaan in permanente opslag in plaats van het interne geheugen van de bot.

Cosmos DB gebruiken

Belangrijk

De Cosmos DB-opslagklasse is afgeschaft. Containers die oorspronkelijk zijn gemaakt met CosmosDbStorage, hadden geen partitiesleutelset en kregen de standaardpartitiesleutel van _/partitionKey.

Containers die zijn gemaakt met Cosmos DB-opslag kunnen worden gebruikt met gepartitioneerde Cosmos DB-opslag. Lees Partitionering in Azure Cosmos DB voor meer informatie.

Houd er ook rekening mee dat, in tegenstelling tot de verouderde Cosmos DB-opslag, de gepartitioneerde Cosmos DB-opslag niet automatisch een database binnen uw Cosmos DB-account maakt. U moet handmatig een nieuwe database maken, maar het handmatig maken van een container overslaan, omdat CosmosDbPartitionedStorage de container voor u maakt.

Nu u geheugenopslag hebt gebruikt, werken we de code bij voor het gebruik van Azure Cosmos DB. Cosmos DB is de wereldwijd gedistribueerde database van Microsoft met meerdere modellen. Met Azure Cosmos DB kunt u doorvoer en opslag elastisch en onafhankelijk schalen in een willekeurig aantal geografische regio's van Azure. Het biedt garanties voor doorvoer, latentie, beschikbaarheid en consistentie met uitgebreide serviceovereenkomsten (SLA's).

Een Cosmos DB-resource instellen

Als u Cosmos DB in uw bot wilt gebruiken, moet u een databaseresource maken voordat u aan de code begint. Zie de quickstart voor .NET, Node.js of Python voor een uitgebreide beschrijving van het maken van een Cosmos DB-database en -app.

Databaseaccount maken

1. Ga naar de Azure-portal om een Azure Cosmos DB-account aan te maken. Zoek en selecteer Azure Cosmos DB.

2. Selecteer nieuw op de pagina Azure Cosmos DB om de pagina Azure Cosmos DB-account maken weer te geven.

   

3. Geef waarden op voor de volgende velden:

   1. Abonnement. Selecteer het Azure-abonnement dat u voor dit Azure Cosmos-account wilt gebruiken.
   2. Resourcegroep. Selecteer een bestaande resourcegroep of selecteer Nieuwe maken en voer een naam in voor een nieuwe resourcegroep.
   3. Accountnaam. Voer een naam in om uw Azure Cosmos-account te identificeren. Gebruik een unieke naam omdat documents.azure.com is toegevoegd aan de naam die u hebt opgegeven om uw URI te maken. Let op de volgende richtlijnen:
      • De naam moet uniek zijn in Azure.
      • De naam moet tussen 3 en 31 tekens lang zijn.
      • De naam kan alleen kleine letters, cijfers en het afbreekstreepje (-) bevatten.
   4. API. Core(SQL) selecteren
   5. Locatie. selecteer een locatie die zich het dichtst bij uw gebruikers bevindt om hen de snelste toegang tot de gegevens te geven.

4. Selecteer Controleren + maken.

5. Nadat de validatie is gevalideerd, selecteert u Maken.

Het duurt enkele minuten om het account te maken. Wacht totdat de portal de gefeliciteerden weergeeft. Uw Azure Cosmos DB-account is gemaakt .

Een database toevoegen

Notitie

Maak de container niet zelf. Uw bot maakt deze voor u bij het maken van de interne Cosmos DB-client, zodat deze correct is geconfigureerd voor het opslaan van de botstatus.

1. Navigeer naar de Data Explorer-pagina in uw zojuist gemaakte Cosmos DB-account en kies vervolgens Nieuwe database in de vervolgkeuzelijst Nieuwe container . Aan de rechterkant van het venster wordt vervolgens een deelvenster geopend, waar u de details voor de nieuwe database kunt invoeren.

   

2. Voer een id in voor uw nieuwe database en stel desgewenst de doorvoer in (u kunt deze later wijzigen) en selecteer ten slotte OK om uw database te maken. Noteer deze database-id voor later gebruik bij het configureren van uw bot.

3. Nu u een Cosmos DB-account en een database hebt gemaakt, moet u een aantal waarden kopiëren voor het integreren van uw nieuwe database in uw bot. Als u deze wilt ophalen, gaat u naar het tabblad Sleutels in de sectie Database-instellingen van uw Cosmos DB-account. Op deze pagina hebt u uw URI (Cosmos DB-eindpunt) en uw PRIMAIRE SLEUTEL (autorisatiesleutel) nodig.

U hebt nu een Cosmos DB-account met een database en de volgende waarden die klaar zijn voor gebruik in de botinstellingen.

• URI
• Primaire sleutel
• Database-id

Cosmos DB-configuratiegegevens toevoegen

Gebruik de details die u in het vorige gedeelte van dit artikel hebt genoteerd om uw eindpunt, autorisatiesleutel en database-id in te stellen. Ten slotte moet u een geschikte naam kiezen voor de container die in uw database wordt gemaakt om de botstatus op te slaan. In het onderstaande voorbeeld krijgt de Cosmos DB-container die wordt gemaakt de naam Bot-Storage.

C#

Voeg de volgende informatie toe aan uw configuratiebestand.

appsettings.json

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

JavaScript

Voeg de volgende informatie toe aan uw .env-bestand .

.Env

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

Python

Voeg de volgende informatie toe aan uw configuratiebestand.

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-pakketten installeren

Zorg ervoor dat u de pakketten hebt die nodig zijn voor Cosmos DB.

C#

Installeer het Microsoft.Bot.Builder.Azure NuGet-pakket. Zie Pakketten installeren en beheren in Visual Studio met behulp van de NuGet-Pakketbeheer voor meer informatie over het gebruik van NuGet.

JavaScript

Voeg een verwijzing toe naar botbuilder-azure met behulp van npm.

npm install --save botbuilder-azure

Als dit nog niet is geïnstalleerd, haalt u het .NET-pakket op van npm om toegang te krijgen tot uw .env-bestandsinstellingen .

npm install --save dotenv

Python

U kunt een verwijzing toevoegen naar botbuilder-azure in uw project via pip.

pip install botbuilder-azure

Cosmos DB-implementatie

Notitie

Versie 4.6 heeft een nieuwe Cosmos DB-opslagprovider geïntroduceerd, de gepartitioneerde opslagklasse van Cosmos DB en de oorspronkelijke Cosmos DB-opslagklasse is afgeschaft. Containers die zijn gemaakt met Cosmos DB-opslag kunnen worden gebruikt met gepartitioneerde Cosmos DB-opslag. Lees Partitionering in Azure Cosmos DB voor meer informatie.

In tegenstelling tot de verouderde Cosmos DB-opslag wordt met de gepartitioneerde opslag van Cosmos DB niet automatisch een database in uw Cosmos DB-account gemaakt. U moet handmatig een nieuwe database maken, maar het handmatig maken van een container overslaan, omdat CosmosDbPartitionedStorage de container voor u maakt.

C#

De volgende voorbeeldcode wordt uitgevoerd met behulp van dezelfde botcode als het bovenstaande geheugenopslagvoorbeeld , met de hier vermelde uitzonderingen. In de onderstaande codefragmenten ziet u een implementatie van Cosmos DB-opslag voor 'myStorage' die de lokale geheugenopslag vervangt.

U moet eerst Startup.cs bijwerken om te verwijzen naar de Azure-bibliotheek van bot builder:

using Microsoft.Bot.Builder.Azure;

Maak vervolgens in de ConfigureServices methode in Startup.cs het CosmosDbPartitionedStorage object. Dit wordt doorgegeven aan de EchoBot constructor via afhankelijkheidsinjectie.

// 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,
        }));

Wijzig in EchoBot.cs de _myStorage variabeledeclaratie private static readonly MemoryStorage _myStorage = new MemoryStorage(); in het volgende:

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

Geef het IStorage object vervolgens door aan de EchoBot constructor:

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

JavaScript

Voeg eerst code toe aan uw index.js-bestand , zodat u toegang hebt tot de waarden uit het .env-bestand dat u eerder hebt ingevoerd:

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

Vervolgens moet u wijzigingen aanbrengen in index.js om gepartitioneerde Cosmos DB-opslag te gebruiken in plaats van de interne opslag van Bot Frameworks. Alle codewijzigingen in deze sectie worden aangebracht in index.js.

Voeg eerst een verwijzing toe naar botbuilder-azure in index.js. Hiermee krijgt u toegang tot de CosmosDbPartitionedStorage klas.

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

Maak vervolgens een nieuw CosmosDbPartitionedStorage object.

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

U kunt nu opmerkingen maken of de myStorage const-declaratie verwijderen die u eerder hebt toegevoegd, omdat u geen gebruikersinvoer meer opslaat in de interne opslag van Bot Frameworks, maar in plaats daarvan naar Cosmos DB:

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

Python

De volgende voorbeeldcode wordt uitgevoerd met behulp van dezelfde botcode als het bovenstaande geheugenopslagvoorbeeld , met de hier vermelde uitzonderingen.

Beide CosmosDbPartitionedStorage en CosmosDbPartitionedConfig van botbuilder-azure zijn vereist om het CosmosDBStorage-object te maken.

echo_bot.py

from botbuilder.azure import CosmosDbPartitionedStorage, CosmosDbPartitionedConfig

Als u toegang wilt krijgen tot de instellingen in config.py, importeert DefaultConfig u zoals hieronder wordt weergegeven:

from config import DefaultConfig
CONFIG = DefaultConfig()

Markeer geheugenopslag in __init__ en vervang deze door verwijzing naar Cosmos DB. Gebruik de URI (eindpunt), primaire sleutel (autorisatiesleutel), database-id en container-id die hierboven worden gebruikt.

Verwijder of commentaar vervolgens de geheugenopslagcode in __init__ en voeg een verwijzing toe naar uw Cosmos DB-gegevens uit config.py.

In het onderstaande codefragment ziet u een implementatie van Cosmos DB voor 'Opslag' die de lokale geheugenopslag vervangt.

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)

Uw Cosmos DB-bot starten

Voer uw bot lokaal uit.

Uw Cosmos DB-bot testen met Bot Framework Emulator

Start nu de Bot Framework Emulator en maak verbinding met uw bot:

1. Selecteer de koppeling voor het maken van een nieuwe botconfiguratie op het tabblad Welkom bij emulator.
2. Vul velden in om verbinding te maken met uw bot, op basis van de informatie op de webpagina die wordt weergegeven toen u de bot startte.

Interactie met uw Cosmos DB-bot

Verzend een bericht naar uw bot en de bot vermeldt de ontvangen berichten.

Uw Cosmos DB-gegevens weergeven

Nadat u uw bot hebt uitgevoerd en uw gegevens hebt opgeslagen, kunt u de gegevens bekijken die zijn opgeslagen in Azure Portal op het tabblad Data Explorer .

Blob Storage gebruiken

Azure Blob Storage is Microsoft's oplossing voor de opslag van objecten in de cloud. Blob Storage is geoptimaliseerd voor het opslaan van grote hoeveelheden ongestructureerde gegevens, zoals tekst of binaire gegevens. In deze sectie wordt uitgelegd hoe u een Azure Blob Storage-account en -container maakt en vervolgens verwijst naar uw Blob Storage-container vanuit uw bot.

Zie Wat is Azure Blob Storage ?

Uw Blob Storage-account maken

Als u Blob Storage in uw bot wilt gebruiken, moet u enkele dingen instellen voordat u de code opent.

1. Selecteer in Azure Portal de optie Alle services.

2. Selecteer Opslagaccounts in de sectie Aanbevolen van de pagina Alle services.

3. Selecteer Nieuw op de pagina Opslagaccounts.

   

4. Selecteer in het veld Abonnement het abonnement waarin u het opslagaccount wilt maken.

5. Selecteer in het veld Resourcegroep een bestaande resourcegroep of selecteer Nieuwe maken en voer een naam in voor de nieuwe resourcegroep.

6. Voer in het veld Opslagaccountnaam een naam in voor het account. Let op de volgende richtlijnen:

   • De naam moet uniek zijn in Azure.
   • De naam moet tussen 3 en 24 tekens lang zijn.
   • De naam mag alleen cijfers en kleine letters bevatten.

7. Selecteer in het veld Locatie een locatie voor het opslagaccount of gebruik de standaardlocatie.

8. Voor de rest van de instellingen configureert u het volgende:

   • Prestaties: Standaard. Meer informatie over prestaties.
   • Soort account: BlobStorage. Meer informatie over opslagaccounts.
   • Replicatie: laat de standaardinstelling staan. Meer informatie over redundantie.

9. Selecteer in de sectie Projectdetails van de pagina Opslagaccount maken de gewenste waarden voor het abonnement en de resourcegroep.

10. Voer in de sectie Instantiedetails van de pagina Opslagaccount maken de naam van het opslagaccount in en selecteer vervolgens waarden voor locatie, soort account en replicatie.

11. Selecteer Beoordelen en maken om de instellingen van het opslagaccount te controleren.

12. Nadat de validatie is gevalideerd, selecteert u Maken.

Blob Storage-container maken

Zodra uw Blob Storage-account is gemaakt, opent u het account en vervolgens:

1. Selecteer Storage Explorer (preview).

2. Klik vervolgens met de rechtermuisknop op BLOBCONTAINERS

3. Selecteer Blobcontainer maken in de vervolgkeuzelijst.

   

4. Voer een naam in het formulier Nieuwe container in. U gebruikt deze naam voor de waarde van uw blobcontainernaam om toegang te verlenen tot uw Blob Storage-account. Let op de volgende richtlijnen:

   • Deze naam mag alleen kleine letters, cijfers en afbreekstreepjes bevatten.
   • Deze naam moet beginnen met een letter of een getal.
   • Elk afbreekstreepje moet worden voorafgegaan en gevolgd door een geldig niet-afbreekstreepje.
   • De naam moet tussen 3 en 63 tekens lang zijn.

Configuratiegegevens voor Blob Storage toevoegen

Zoek de Blob Storage-sleutels die u nodig hebt om Blob Storage voor uw bot te configureren, zoals hierboven wordt weergegeven:

1. Open uw Blob Storage-account in Azure Portal en selecteer Toegangssleutels in de sectie Instellingen .
2. Als u uw bot wilt configureren voor toegang tot uw Blob Storage-account, gebruikt u de verbindingsreeks als de waarde voor de blob-verbindingsreeks.

C#

Voeg de volgende informatie toe aan uw configuratiebestand.

appsettings.json

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

JavaScript

Voeg de volgende informatie toe aan uw .env-bestand .

.Env

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

Python

Voeg de volgende informatie toe aan uw configuratiebestand. Gebruik dezelfde containernaam en verbindingsreeks gebruikt bij het maken van uw blobopslagcontainer.

config.py

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

Blob Storage-pakketten installeren

Als deze niet eerder is geïnstalleerd, installeert u de volgende pakketten.

C#

Installeer het NuGet-pakket Microsoft.Bot.Builder.Azure.Blobs . Zie Pakketten installeren en beheren in Visual Studio met behulp van de NuGet-Pakketbeheer voor meer informatie over het gebruik van NuGet.

JavaScript

Voeg verwijzingen toe aan botbuilder-azure-blobs uw project via npm.

Notitie

Dit NPM-pakket is afhankelijk van een installatie van Python die bestaat op uw ontwikkelcomputer. Als u Python nog niet eerder hebt geïnstalleerd, kunt u installatiebronnen voor uw computer vinden op Python.org

npm install --save botbuilder-azure-blobs

Als dit nog niet is geïnstalleerd, haalt u het .NET-pakket op van npm om toegang te krijgen tot uw .env-bestandsinstellingen .

npm install --save dotenv

Python

u kunt een verwijzing toevoegen naar botbuilder-azure in uw project via pip.

pip install botbuilder-azure

Implementatie van Blob Storage

Blob Storage wordt gebruikt om de botstatus op te slaan.

C#

Notitie

Vanaf versie 4.10 Microsoft.Bot.Builder.Azure.AzureBlobStorage is afgeschaft. Gebruik de nieuwe Microsoft.Bot.Builder.Azure.Blobs.BlobsStorage op zijn plaats.

De volgende voorbeeldcode wordt uitgevoerd met behulp van dezelfde botcode als het bovenstaande geheugenopslagvoorbeeld , met de hier vermelde uitzonderingen.

In de onderstaande codefragmenten ziet u een implementatie van Blob Storage voor 'myStorage' die lokale geheugenopslag vervangt.

U moet eerst Startup.cs bijwerken om te verwijzen naar de Azure-blobs-bibliotheek voor botbouwer:

Startup.cs

using Microsoft.Bot.Builder.Azure.Blobs;

Maak vervolgens in de ConfigureServices methode in Startup.cs het BlobsStorage object, waarbij de waarden worden doorgegeven uit appsettings.json. Dit wordt doorgegeven aan de EchoBot constructor via afhankelijkheidsinjectie.

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

Nu moet u eerst EchoBot.cs bijwerken om te verwijzen naar de Azure-blobs-bibliotheek voor bot builder:

EchoBot.cs

using Microsoft.Bot.Builder.Azure.Blobs;

Verwijder of markeer vervolgens de coderegel waarmee de MemoryStorage-variabele 'persoonlijke statische readonly MemoryStorage _myStorage = new MemoryStorage();' wordt gemaakt en maak een nieuwe variabele die wordt gebruikt om gebruikersinvoer op te slaan in blobopslag.

EchoBot.cs

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

Geef het IStorage object vervolgens door aan de EchoBot constructor:

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

Zodra uw opslag is ingesteld om te verwijzen naar uw Blob Storage-account, slaat uw botcode nu gegevens op uit Blob Storage en haalt u deze op.

JavaScript

Alle codewijzigingen in deze sectie worden aangebracht in index.js.

Voeg eerst code toe waarmee u toegang hebt tot de waarden uit uw .env-bestand dat u eerder hebt ingevoerd:

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

Vervolgens moet u wijzigingen aanbrengen in Blob Storage in plaats van de interne opslag van Bot Frameworks.

Voeg vervolgens een verwijzing toe naar botbuilder-azure-blobs. Hiermee hebt u toegang tot de Blob Storage-API:

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

Als u de code wilt wijzigen om de BlobsStorage klasse te gebruiken, wijzigt u uw myStorage declaratie als volgt:

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

Zodra uw opslag is ingesteld om te verwijzen naar uw Blob Storage-account, slaat uw botcode nu gegevens op uit Blob Storage en haalt u deze op.

Python

De volgende voorbeeldcode wordt uitgevoerd met behulp van dezelfde botcode als het bovenstaande geheugenopslagvoorbeeld , met de hier vermelde uitzonderingen.

Hiervoor is BlobStorage vereist en BlobStorageSettings van botbuilder-azure.

echo_bot.py

from botbuilder.azure import BlobStorage, BlobStorageSettings

Als u toegang wilt krijgen tot de instellingen in config.py, importeert DefaultConfig u zoals hieronder wordt weergegeven:

from config import DefaultConfig
CONFIG = DefaultConfig()

Verwijder of markeer vervolgens de geheugenopslagcode in __init__ en voeg een verwijzing toe naar uw blobopslaggegevens uit config.py.

In het onderstaande codefragment ziet u een implementatie van Blob Storage die de lokale geheugenopslag vervangt.

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)

Zodra uw opslag is ingesteld om te verwijzen naar uw Blob Storage-account, slaat uw botcode nu gegevens op uit Blob Storage en haalt u deze op.

Uw Blob Storage-bot starten

Voer uw bot lokaal uit.

De emulator starten en uw Blob Storage-bot verbinden

Start vervolgens de emulator en maak vervolgens verbinding met uw bot in de emulator:

1. Selecteer de koppeling Nieuwe botconfiguratie maken op het tabblad 'Welkom' van de emulator.
2. Vul velden in om verbinding te maken met uw bot, op basis van de informatie op de webpagina die wordt weergegeven toen u de bot startte.

Interactie met uw Blob Storage-bot

Verzend een bericht naar uw bot en de bot vermeldt de berichten die de bot ontvangt.

Uw Blob Storage-gegevens weergeven

Nadat u uw bot hebt uitgevoerd en uw gegevens hebt opgeslagen, kunnen we deze bekijken op het tabblad Storage Explorer in Azure Portal.

Blobtranscriptieopslag

Azure Blob Transcript Storage biedt een gespecialiseerde opslagoptie waarmee u eenvoudig gebruikersgesprekken kunt opslaan en ophalen in de vorm van een opgenomen transcriptie. Azure Blob Transcript Storage is handig voor het automatisch vastleggen van gebruikersinvoer die moeten worden onderzocht tijdens het opsporen van fouten in de prestaties van uw bot.

Notitie

Python biedt momenteel geen ondersteuning voor Azure Blob Transcript Storage. Hoewel JavaScript blobtranscriptopslag ondersteunt, zijn de volgende aanwijzingen alleen voor C#.

Een blobtranscriptieopslagcontainer instellen

Azure Blob Transcript Storage kan gebruikmaken van hetzelfde blob-opslagaccount dat is gemaakt volgens de stappen in de secties 'Uw blobopslagaccount maken' en 'Configuratiegegevens toevoegen' hierboven. We voegen nu een container toe voor het opslaan van onze transcripties

1. Open uw Azure Blob Storage-account.
2. Selecteer Storage Explorer.
3. Klik met de rechtermuisknop op BLOBCONTAINERs en selecteer Blob-container maken.
4. Voer een naam in voor uw transcriptcontainer en selecteer VERVOLGENS OK. (We hebben mybottranscripts ingevoerd)

Implementatie van blobtranscriptieopslag

Met de volgende code wordt de transcriptopslagpointer _myTranscripts verbonden met uw nieuwe Azure Blob Transcript Storage-account. Als u deze koppeling wilt maken met een nieuwe containernaam, <uw-blob-transcript-containernaam, wordt er een nieuwe container in Blob-opslag> gemaakt om uw transcriptbestanden op te slaan.

Blobtranscriptieopslag is ontworpen voor het opslaan van bottranscripties.

Notitie

Vanaf versie 4.10 Microsoft.Bot.Builder.Azure.AzureBlobTranscriptStore is afgeschaft. Gebruik de nieuwe Microsoft.Bot.Builder.Azure.Blobs.BlobsTranscriptStore op zijn plaats.

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>");

   ...
}

Gebruikersgesprekken opslaan in Azure Blob-transcripties

Nadat een blobcontainer beschikbaar is voor het opslaan van transcripties, kunt u beginnen met het behouden van gesprekken van uw gebruikers met uw bot. Deze gesprekken kunnen later worden gebruikt als een hulpprogramma voor foutopsporing om te zien hoe gebruikers met uw bot werken. Elk gesprek over opnieuw opstarten van de emulator start het maken van een nieuwe transcriptiegesprekslijst. De volgende code behoudt invoer van gebruikersgesprekken in een opgeslagen transcriptiebestand.

• De huidige transcriptie wordt opgeslagen met behulp van LogActivityAsync.
• Opgeslagen transcripties worden opgehaald met behulp van ListTranscriptsAsync. In deze voorbeeldcode wordt de id van elke opgeslagen transcriptie opgeslagen in een lijst met de naam 'storedTranscripts'. Deze lijst wordt later gebruikt om het aantal opgeslagen blobtranscripties te beheren dat we bewaren.

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);

    ...
}

Opgeslagen blobtranscripties beheren

Hoewel opgeslagen transcripties kunnen worden gebruikt als hulpprogramma voor foutopsporing, kan het aantal opgeslagen transcripties na verloop van tijd groter worden dan u wilt behouden. De onderstaande aanvullende code gebruikt DeleteTranscriptAsync om alle, maar de laatste drie opgehaalde transcriptitems uit uw blobtranscriptiearchief te verwijderen.

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);
           }
       }
    }
    ...
}

Zie Azure Blob Transcript Storage voor meer informatie over de klasse.

Aanvullende informatie

Gelijktijdigheid beheren met behulp van eTags

In ons voorbeeld van botcode stellen we de eTag eigenschap van elk IStoreItem ervan in op *. Het eTag lid (entiteitstag) van uw winkelobject wordt in Cosmos DB gebruikt om gelijktijdigheid te beheren. De eTag database vertelt wat u moet doen als een ander exemplaar van de bot het object heeft gewijzigd in dezelfde opslag waarnaar uw bot schrijft.

Last write wins - allow overwrites

Een eTag eigenschapswaarde van sterretje (*) geeft aan dat de laatste schrijver wint. Wanneer u een nieuw gegevensarchief maakt, kunt u een eigenschap instellen eTag om aan te * geven dat u de gegevens die u schrijft niet eerder hebt opgeslagen, of dat u wilt dat de laatste schrijver een eerder opgeslagen eigenschap overschrijft. Als gelijktijdigheid geen probleem is voor uw bot, kunt u de eTag eigenschap * instellen op gegevens die u schrijft, overschrijven.

Gelijktijdigheid behouden en overschrijven voorkomen

Wanneer u uw gegevens opslaat in Cosmos DB, gebruikt u een andere waarde dan * voor de eTag als u gelijktijdige toegang tot een eigenschap wilt voorkomen en wijzigingen van een ander exemplaar van de bot wilt overschrijven. De bot ontvangt een foutbericht met het bericht etag conflict key= wanneer wordt geprobeerd statusgegevens op te slaan en de eTag waarde is niet dezelfde waarde als de in de eTag opslag.

Standaard controleert het Cosmos DB-archief de eTag eigenschap van een opslagobject op gelijkheid telkens wanneer een bot naar dat item schrijft en werkt het vervolgens bij naar een nieuwe unieke waarde na elke schrijfbewerking. Als de eTag eigenschap bij schrijven niet overeenkomt met de eTag opslag, betekent dit dat een andere bot of thread de gegevens heeft gewijzigd.

Stel dat u wilt dat uw bot een opgeslagen notitie bewerkt, maar u niet wilt dat uw bot wijzigingen overschrijft die door een ander exemplaar van de bot zijn uitgevoerd. Als een ander exemplaar van de bot wijzigingen heeft aangebracht, wilt u dat de gebruiker de versie bewerkt met de meest recente updates.

C#

Maak eerst een klasse die wordt geïmplementeerd IStoreItem.

EchoBot.cs

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

Maak vervolgens een eerste notitie door een opslagobject te maken en voeg het object toe aan uw winkel.

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);

Vervolgens kunt u de notitie later openen en bijwerken, zodat eTag u de notitie in de store kunt lezen.

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);
}

Als de notitie in de store is bijgewerkt voordat u uw wijzigingen schrijft, genereert de aanroep een Write uitzondering.

JavaScript

Voeg een helperfunctie toe aan het einde van uw bot waarmee een voorbeeldnotitie naar een gegevensarchief wordt geschreven. Maak eerst een myNoteData object.

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: "*"
    }
}

Initialiseer een changes object in de createSampleNote helperfunctie en voeg uw notities eraan toe en schrijf het vervolgens naar de opslag.

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}`);
}

De helperfunctie wordt geopend vanuit de logica van uw bot door de volgende aanroep toe te voegen:

bot.js

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

Als u de notitie later wilt ophalen en bijwerken, maken we een andere helperfunctie die kan worden geopend wanneer de gebruiker 'notitie bijwerken' typt.

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}`);
    }
}

Deze helperfunctie wordt geopend vanuit de logica van uw bot door de volgende aanroep toe te voegen:

bot.js

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

Als de notitie door een andere gebruiker is bijgewerkt in de store voordat u uw wijzigingen terugschrijft, komt de eTag waarde niet meer overeen en genereert de aanroep een write uitzondering.

Python

Maak eerst een klasse die wordt geïmplementeerd 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

Maak vervolgens een eerste notitie door een opslagobject te maken en voeg het object toe aan uw winkel.

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)

Vervolgens kunt u de notitie later openen en bijwerken, zodat eTag u de notitie in de store kunt lezen.

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)

Als de notitie in de store is bijgewerkt voordat u uw wijzigingen schrijft, genereert de aanroep een write uitzondering.

Als u gelijktijdigheid wilt behouden, leest u altijd een eigenschap uit de opslag en wijzigt u vervolgens de eigenschap die u hebt gelezen, zodat de eTag eigenschap wordt onderhouden. Als u gebruikersgegevens uit het archief leest, bevat het antwoord de eigenschap eTag. Als u de gegevens wijzigt en bijgewerkte gegevens naar het archief schrijft, moet uw aanvraag de eTag-eigenschap bevatten die dezelfde waarde aangeeft als u eerder hebt gelezen. Als u echter een object schrijft met eTag de bijbehorende set, * kan de schrijfbewerking andere wijzigingen overschrijven.

Volgende stappen

Nu u weet hoe u rechtstreeks vanuit de opslag kunt lezen en schrijven, gaan we kijken hoe u de statusbeheerder kunt gebruiken om dat voor u te doen.

Status opslaan met behulp van gespreks- en gebruikerseigenschappen