直接写入到存储

将 EchoBot.cs 中的代码替换为以下代码：

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

若要使用 .env 配置文件，你的机器人需要额外安装一个软件包。 如果尚未安装 .NET 包，请从 npm 获取它：

npm install --save dotenv

修改 index.js 中创建主对话的代码。 创建主对话的现有代码行是 const myBot = new EchoBot();，它需要更新才能将存储对象传递给 EchoBot 构造函数，以便可以将用户的输入存储到机器人的内部内存：

首先，你将需要在 MemoryStorage 中添加对 botbuilder 的引用：

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

然后创建一个内存存储对象，并将其传递到 EchoBot 构造函数：

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

将一个 MemoryStorage 对象传递给 EchoBot 构造函数。 稍后你会将其更改为传递 Cosmos DB 或 Blob 存储 对象。

接下来，在 bot.js 中，将代码替换为以下代码：

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://docs.azure.cn/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;

用下面的代码替换 echo_bot.py 中的代码：

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

在配置文件中添加以下信息。

appsettings.json

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

在 .env 文件中添加以下信息。

.env

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

在配置文件中添加以下信息。

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"

安装 Microsoft.Bot.Builder.Azure NuGet 包。 有关使用 NuGet 的详细信息，请参阅使用 NuGet 包管理器在 Visual Studio 中安装和管理包。

使用 npm 添加对 botbuilder-azure 的引用。

npm install --save botbuilder-azure

如果尚未安装 .NET 包，请从 npm 获取该包以访问 .env 文件设置。

npm install --save dotenv

可以通过 PIP 在项目中添加对 botbuilder-azure 的引用。

pip install botbuilder-azure

以下示例代码运行时，使用的是与上面提供的内存存储示例相同的机器人代码，差异之处于此列出。 以下代码段演示如何为“myStorage”实现 Cosmos DB 存储，替换本地内存存储。

首先需要更新 Startup.cs 以引用 Bot Builder Azure 库：

using Microsoft.Bot.Builder.Azure;

接下来，在 Startup.cs 中的 ConfigureServices 方法里，创建 CosmosDbPartitionedStorage 对象。 这将通过依赖项注入传递到 EchoBot 构造函数中。

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

在 EchoBot.cs 中，将 _myStorage 变量声明 private static readonly MemoryStorage _myStorage = new MemoryStorage(); 更改为以下内容：

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

然后向 IStorage 构造函数传入 EchoBot 对象：

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

首先，将代码添加到 index.js 文件，以便访问前面输入的 .env 文件中的值：

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

接下来，需要更改 index.js 以使用 Cosmos DB 分区存储，而不是使用 Bot Frameworks 内部存储。 本部分中的所有代码更改都是在 index.js 中进行的。

首先，在 index.js 中添加对 botbuilder-azure 的引用。 这将授予你对 CosmosDbPartitionedStorage 类的访问权限。

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

接下来，创建一个新的 CosmosDbPartitionedStorage 对象。

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

现在可以注释掉或删除之前添加的 myStorage const 声明，因为不再将用户输入保存到 Bot Frameworks 内部存储，而是将其保存到 Cosmos DB：

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

以下示例代码运行时，使用的是与上面提供的内存存储示例相同的机器人代码，差异之处于此列出。

需要 CosmosDbPartitionedStorage 中的 CosmosDbPartitionedConfig 和 botbuilder-azure，以创建 CosmosDBStorage 对象。

echo_bot.py

from botbuilder.azure import CosmosDbPartitionedStorage, CosmosDbPartitionedConfig

若要访问 config.py 中的设置，需要导入 DefaultConfig，如下所示：

from config import DefaultConfig
CONFIG = DefaultConfig()

注释掉 __init__ 中的内存存储，并将其替换为对 Cosmos DB 的引用。 使用上面用到的 URI（终结点）、主密钥（授权密钥）、数据库 ID 和容器 ID。

接下来，删除或注释掉 __init__ 中的内存存储代码，并从 config.py 添加对 Cosmos DB 信息的引用。

以下代码段演示如何为“Storage”实现 Cosmos DB，替换本地内存存储。

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)

在配置文件中添加以下信息。

appsettings.json

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

在 .env 文件中添加以下信息。

.env

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

在配置文件中添加以下信息。 使用创建 Blob 存储容器时使用的相同容器名称和连接字符串。

config.py

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

安装 Microsoft.Bot.Builder.Azure.Blobs NuGet 包。 有关使用 NuGet 的详细信息，请参阅使用 NuGet 包管理器在 Visual Studio 中安装和管理包。

通过 npm 在项目中添加对 botbuilder-azure-blobs 的引用。

npm install --save botbuilder-azure-blobs

如果尚未安装 .NET 包，请从 npm 获取该包以访问 .env 文件设置。

npm install --save dotenv

可以通过 pip 在项目中添加对 botbuilder-azure 的引用。

pip install botbuilder-azure

以下示例代码运行时，使用的是与上面提供的内存存储示例相同的机器人代码，差异之处于此列出。

以下代码段演示如何为“myStorage”实现 Blob 存储，替换本地内存存储。

首先需要更新 Startup.cs 以引用 Bot Builder Azure blob 库：

Startup.cs

using Microsoft.Bot.Builder.Azure.Blobs;

接下来，在 Startup.cs 的 ConfigureServices 方法中，创建 BlobsStorage 对象，并将来自 appsettings.json 的值传入其中。 这将通过依赖项注入传递到 EchoBot 构造函数中。

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

首先需要更新 EchoBot.cs 以引用 Bot Builder Azure blob 库：

EchoBot.cs

using Microsoft.Bot.Builder.Azure.Blobs;

接下来，删除或注释掉创建 MemoryStorage 变量的代码行“private static readonly MemoryStorage _myStorage = new MemoryStorage();”，并创建一个新变量，用于将用户输入保存到 Blob 存储。

EchoBot.cs

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

然后向 IStorage 构造函数传入 EchoBot 对象：

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

将存储配置为指向 Blob 存储帐户后，机器人代码现在将从 Blob 存储中存储和检索数据。

本部分中的所有代码更改都是在 index.js 中进行的。

首先，添加代码以便访问前面输入的 .env 文件中的值：

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

接下来，您需要进行更改，以使用 Blob 存储来代替 Bot Framework 的内部存储。

接下来，添加对 botbuilder-azure-blobs 的引用。 这将授予对 Blob 存储 API 的访问权限：

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

若要修改代码以使用 BlobsStorage 类，请修改 myStorage 声明，如下所示：

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

将存储配置为指向 Blob 存储帐户后，机器人代码现在会将数据存储到 Blob 存储中并从中检索数据。

以下示例代码运行时，使用的是与上面提供的内存存储示例相同的机器人代码，差异之处于此列出。

这将需要来自 botbuilder-azure 的 BlobStorage 和 BlobStorageSettings。

echo_bot.py

from botbuilder.azure import BlobStorage, BlobStorageSettings

若要访问 config.py 中的设置，需要导入 DefaultConfig，如下所示：

from config import DefaultConfig
CONFIG = DefaultConfig()

接下来，删除或注释掉 __init__ 中的内存存储代码，并从 config.py 添加对 Blob 存储信息的引用。

以下代码段演示如何实现 Blob 存储，替换本地内存存储。

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)

首先，创建实现 IStoreItem 的类。

EchoBot.cs

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

接下来，通过创建存储对象创建初始注释，并将该对象添加到存储。

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

然后，稍后访问并更新该备注，同时保留你从存储中读取到的其 eTag。

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

如果在写入变更之前在存储中更新了注释，调用 Write 将引发异常。

请将一个帮助程序函数添加到机器人末尾，该机器人会将示例注释写入到数据存储中。 首先创建 myNoteData 对象。

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 辅助函数中，初始化一个 changes 对象并向其中添加你的 注释，然后将其写入存储。

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

可以通过添加以下调用，从机器人逻辑内部访问该帮助器函数：

bot.js

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

创建后，为了在以后检索和更新此注释，我们创建了另一个帮助器函数。当用户键入“update note”时，就可以访问该函数。

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

可以通过添加以下调用，从机器人逻辑内部访问此帮助器函数：

bot.js

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

如果在你尝试写回更改之前，另一个用户更新了存储中的注释，则 eTag 值将不再匹配，并且调用 write 将引发异常。

首先，创建实现 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

接下来，通过创建存储对象创建初始注释，并将该对象添加到存储。

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)

然后，在之后访问并更新该注释，同时保留你从存储中读取的 eTag。

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)

如果在写入变更之前在存储中更新了注释，调用 write 将引发异常。