c# - 了解为什么在 Bot Builder Framework 示例 : MultiLingualBot 中似乎进行了三次翻译

Question

在机器人的中间件中提供语言翻译的微软官方示例似乎提供了在中间件中以 3 种不同的时间/方式触发的语言翻译。

我的问题是为什么这 3 种不同的类型/方式不重叠。 (触发器如何相互排斥？)

有问题的代码存在 here

似乎被触发的三次:

1)  if (turnContext.Activity.Type == ActivityTypes.Message) //trigger translation
2) turnContext.OnSendActivities(async (newContext, activities, nextSend) => //trigger translation
3) turnContext.OnUpdateActivity(async (newContext, activity, nextUpdate) => //trigger translation

一个单独的问题可能有助于增加清晰度 -> 文档说... "beware short circuiting"你的中间件，但不清楚我是如何(有意或无意地)短路他们的中间件的。以下两个 return 语句中的任何一个是否会使中间件短路？

                return await nextSend(); //LINE 83 at time of writing

                return await nextUpdate(); //LINE 100 at time of writing

对于后代，引用的代码是:

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

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

namespace Microsoft.BotBuilderSamples.Translation
{
    /// <summary>
    /// Middleware for translating text between the user and bot.
    /// Uses the Microsoft Translator Text API.
    /// </summary>
    public class TranslationMiddleware : IMiddleware
    {
        private readonly MicrosoftTranslator _translator;
        private readonly IStatePropertyAccessor<string> _languageStateProperty;

        /// <summary>
        /// Initializes a new instance of the <see cref="TranslationMiddleware"/> class.
        /// </summary>
        /// <param name="translator">Translator implementation to be used for text translation.</param>
        /// <param name="languageStateProperty">State property for current language.</param>
        public TranslationMiddleware(MicrosoftTranslator translator, UserState userState)
        {
            _translator = translator ?? throw new ArgumentNullException(nameof(translator));
            if(userState == null)
            {
                throw new ArgumentNullException(nameof(userState));
            }

            _languageStateProperty = userState.CreateProperty<string>("LanguagePreference");
        }

        /// <summary>
        /// Processes an incoming activity.
        /// </summary>
        /// <param name="turnContext">Context object containing information for a single turn of conversation with a user.</param>
        /// <param name="next">The delegate to call to continue the bot middleware pipeline.</param>
        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
        public async Task OnTurnAsync(ITurnContext turnContext, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (turnContext == null)
            {
                throw new ArgumentNullException(nameof(turnContext));
            }

            var translate = await ShouldTranslateAsync(turnContext, cancellationToken);

            if (translate)
            {
                if (turnContext.Activity.Type == ActivityTypes.Message)
                {
                    turnContext.Activity.Text = await _translator.TranslateAsync(turnContext.Activity.Text, TranslationSettings.DefaultLanguage, cancellationToken);
                }
            }

            turnContext.OnSendActivities(async (newContext, activities, nextSend) =>
            {
                string userLanguage = await _languageStateProperty.GetAsync(turnContext, () => TranslationSettings.DefaultLanguage) ?? TranslationSettings.DefaultLanguage;
                bool shouldTranslate = userLanguage != TranslationSettings.DefaultLanguage;

                // Translate messages sent to the user to user language
                if (shouldTranslate)
                {
                    List<Task> tasks = new List<Task>();
                    foreach (Activity currentActivity in activities.Where(a => a.Type == ActivityTypes.Message))
                    {
                        tasks.Add(TranslateMessageActivityAsync(currentActivity.AsMessageActivity(), userLanguage));
                    }

                    if (tasks.Any())
                    {
                        await Task.WhenAll(tasks).ConfigureAwait(false);
                    }
                }

                return await nextSend();
            });

            turnContext.OnUpdateActivity(async (newContext, activity, nextUpdate) =>
            {
                string userLanguage = await _languageStateProperty.GetAsync(turnContext, () => TranslationSettings.DefaultLanguage) ?? TranslationSettings.DefaultLanguage;
                bool shouldTranslate = userLanguage != TranslationSettings.DefaultLanguage;

                // Translate messages sent to the user to user language
                if (activity.Type == ActivityTypes.Message)
                {
                    if (shouldTranslate)
                    {
                        await TranslateMessageActivityAsync(activity.AsMessageActivity(), userLanguage);
                    }
                }

                return await nextUpdate();
            });

            await next(cancellationToken).ConfigureAwait(false);
        }

        private async Task TranslateMessageActivityAsync(IMessageActivity activity, string targetLocale, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (activity.Type == ActivityTypes.Message)
            {
                activity.Text = await _translator.TranslateAsync(activity.Text, targetLocale);
            }
        }

        private async Task<bool> ShouldTranslateAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken))
        {
            string userLanguage = await _languageStateProperty.GetAsync(turnContext, () => TranslationSettings.DefaultLanguage, cancellationToken) ?? TranslationSettings.DefaultLanguage;
            return userLanguage != TranslationSettings.DefaultLanguage;
        }
    }
}

Answer 1

当机器人收到某些类型的事件时，需要进行消息翻译。某些类型的事件不需要翻译。该协议(protocol)的事件类型可以在here中找到。

        "message",
        "contactRelationUpdate",
        "conversationUpdate",
        "typing",
        "endOfConversation",
        "event",
        "invoke",
        "deleteUserData",
        "messageUpdate",
        "messageDelete",
        "installationUpdate",
        "messageReaction",
        "suggestion",
        "trace",
        "handoff"

MultiLingualBot 示例演示了翻译:

1) 将传入消息事件传入 TranslationSettings.DefaultLanguage 以便由机器人处理

2) 传出消息事件恢复为用户的首选语言

3)消息更新事件

1)  if (turnContext.Activity.Type == ActivityTypes.Message) //trigger translation
2) turnContext.OnSendActivities(async (newContext, activities, nextSend) => //trigger translation
3) turnContext.OnUpdateActivity(async (newContext, activity, nextUpdate) => //trigger translation

短路中间件将不会调用

await next(cancellationToken).ConfigureAwait(false);
or 
return await nextSend();
or
return await nextUpdate();

如果不调用这些函数，消息处理就会停止。堆栈中的其他中间件不会处理传入的消息。