C# Microsoft应用程序ID xxx的授权失败，状态代码为禁止，原因短语为'；禁止'；

我的机器人在以下代码行中不断失败，Skype、WebChat和FB chat中出现错误。我已尝试通过应用程序设置和web.config输入MS应用程序ID和密码。这在模拟器中运行良好，没有任何错误。当我运行远程调试时，我发现这在Webchat、Skype和FB messenger上失败，代码如下：

await connector.Conversations.ReplyToActivityAsync(reply1);

我的机器人与SmartThings集成在一起，因此智能配件可以按预期打开和关闭，但聊天中应该返回的响应似乎失败了。我尝试创建一个新的机器人服务应用程序，但也失败了

更新包括所有代码：

using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http;
using Microsoft.Bot.Connector;
using System.Net.Http.Headers;
using System.Threading;
using Microsoft.IdentityModel.Protocols;
using System.Configuration;

namespace FirstBotApp
{
[BotAuthentication]

public class Switches
{
    public string name { get; set; }
    public string value { get; set; }

}



public class MessagesController : ApiController
{

    static HttpClient client = new HttpClient();
    static HttpResponseMessage responsemain = null;
    static int j = 0;

    static void ShowSwitches(Switches[] switches)
    {

        for (int i = switches.Length - 1; i >= 0; i--)
        {
            Console.WriteLine($"Name: {switches[i].name}\tPrice: {switches[i].value}\t");
        }
        return;
    }

    static async Task<Switches[]> GetSwitchesAsync(string path)
    {
        Switches[] switches = null;
        responsemain = await client.GetAsync(path);
        //Console.WriteLine(client.GetAsync(path));
        //Console.WriteLine(response);
        if (responsemain.IsSuccessStatusCode)
        {
            //Console.WriteLine($"Successful response: {response.StatusCode}");
            var response1 = await client.GetStringAsync("");
            Console.WriteLine($"{response1}");

            switches = await responsemain.Content.ReadAsAsync<Switches[]>();

            //JObject j = JObject.Parse(response1);
        }
        else Console.WriteLine($"Error in response: {responsemain.StatusCode}");

        return switches;
    }

    static async Task<Switches> UpdateSwitchesAsync(Switches switches)
    {
        Console.WriteLine("Turning off the light");
        HttpResponseMessage response = await client.PutAsJsonAsync($"switches/off?room=LivingRoom", switches);
        response.EnsureSuccessStatusCode();
        Console.WriteLine($"The response from the server was: {response.StatusCode}");

        // Deserialize the updated switches from the response body.
        switches = await response.Content.ReadAsAsync<Switches>();
        Thread.Sleep(10000);
        Console.WriteLine($"Turning on the light");

        response = await client.PutAsJsonAsync($"switches/on?room=LivingRoom", switches);
        Console.WriteLine($"The response from the server was: {response.StatusCode}");
        Thread.Sleep(10000);
        return switches;
    }

    static async Task<HttpStatusCode> DeleteSwitchesAsync(string id)
    {
        HttpResponseMessage response = await client.DeleteAsync($"api/switchess/{id}");
        return response.StatusCode;
    }


    /// <summary>
    /// POST: api/Messages
    /// Receive a message from a user and reply to it
    /// </summary>
    public async Task<HttpResponseMessage> Post([FromBody]Activity activity)
    {

        Switches[] switches = null;
        ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl));
        //string appdId = AppSettings.Settings["MicrosoftAppId"];
        //string appPassword = ConfigurationManager.AppSettings["MicrosoftAppPassword"];
        if (j == 0)
        {
            //client.Timeout = TimeSpan.FromSeconds(4);

            //Declaration of client and Switches variable

            string accessToken = "xxxxx";
            client.BaseAddress = new Uri("xxxxx");
            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            client.DefaultRequestHeaders.Add("Authorization", "Bearer " + accessToken);
            j++;
            //client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue ("Authorization", "Bearer " + accessToken);
        }

        if (activity.Type == ActivityTypes.Message)
        {
            //, appdId, appPassword);
            //Switches switches = new Switches;
            Activity reply1;// = activity.CreateReply($"breakpoint1");
                            //await connector.Conversations.ReplyToActivityAsync(reply1);


            switch (activity.Text.ToLower())
            {
                case"turn on livingroom":
                    try
                    {
                        Console.WriteLine("Turning on the light");
                        responsemain = await client.PutAsJsonAsync($"switches/on?room=LivingRoom", switches);
                        responsemain.EnsureSuccessStatusCode();
                        //Console.WriteLine($"The response from the server was: {responsemain.StatusCode}");

                        // Deserialize the updated product from the response body.
                        switches = await responsemain.Content.ReadAsAsync<Switches[]>();
                        reply1 = activity.CreateReply($"Successfully turned on LivingRoom Light");
                        await connector.Conversations.ReplyToActivityAsync(reply1);
                    }
                    catch
                    {
                        reply1 = activity.CreateReply($"Error");
                        await connector.Conversations.ReplyToActivityAsync(reply1);
                    }
                    break;


                case "turn off livingroom":
                    try
                    {
                        Console.WriteLine("Turning off the light");
                        responsemain = await client.PutAsJsonAsync($"switches/off?room=LivingRoom", switches);
                        responsemain.EnsureSuccessStatusCode();
                        Console.WriteLine($"The response from the server was: {responsemain.StatusCode}");

                        // Deserialize the updated product from the response body.
                        switches = await responsemain.Content.ReadAsAsync<Switches[]>();
                        reply1 = activity.CreateReply($"Successfully turned off LivingRoom Light");
                        await connector.Conversations.ReplyToActivityAsync(reply1);
                    }

                    catch
                    {
                        reply1 = activity.CreateReply($"Error");
                        await connector.Conversations.ReplyToActivityAsync(reply1);
                    }
                    break;


                default: //"What lights are on?":
                    try
                    {
                        switches = await GetSwitchesAsync("");
                        //Console.WriteLine($"About to show the product");
                        ShowSwitches(switches);
                        //await connector.Conversations.ReplyToActivityAsync(switches[].ToString);

                        for (int i = switches.Length - 1; i >= 0; i--)
                        {
                            reply1 = activity.CreateReply($"Room: ");//{switches[i].name}\tStatus: {switches[i].value}\t");
                            responsemain.EnsureSuccessStatusCode();

                            await connector.Conversations.ReplyToActivityAsync(reply1);
                        }



                        break;
                    }
                    catch
                    {

                    }
                    break;




            }

            // calculate something for us to return
            //int length = (activity.Text ?? string.Empty).Length;

            // return our reply to the user
            //Activity reply = activity.CreateReply($"You sent {activity.Text} which was {length} characters");
            //await connector.Conversations.ReplyToActivityAsync(reply);
        }
        else
        {
            HandleSystemMessage(activity);
        }
        // var response = Request.CreateResponse(HttpStatusCode.OK);

        return responsemain;
    }

    static Activity HandleSystemMessage(Activity message)
    {
        if (message.Type == ActivityTypes.DeleteUserData)
        {
            // Implement user deletion here
            // If we handle user deletion, return a real message
        }
        else if (message.Type == ActivityTypes.ConversationUpdate)
        {
            // Handle conversation state changes, like members being added and removed
            // Use Activity.MembersAdded and Activity.MembersRemoved and Activity.Action for info
            // Not available in all channels
        }
        else if (message.Type == ActivityTypes.ContactRelationUpdate)
        {
            // Handle add/remove from contact lists
            // Activity.From + Activity.Action represent what happened
        }
        else if (message.Type == ActivityTypes.Typing)
        {
            // Handle knowing tha the user is typing
        }
        else if (message.Type == ActivityTypes.Ping)
        {
        }

        return null;
    }``
    //client.dispose();

}
}

使用系统；
Net系统；
使用System.Net.Http；
使用System.Threading.Tasks；
使用System.Web.Http；
使用Microsoft.Bot.Connector；
使用System.Net.Http.Header；
使用系统线程；
使用Microsoft.IdentityModel.Protocols；
使用系统配置；
命名空间FirstBotApp
{
[身份验证]
公共类交换机
{
公共字符串名称{get；set；}
公共字符串值{get；set；}
}
公共类消息控制器：ApiController
{
静态HttpClient=新HttpClient（）；
静态HttpResponseMessageResponseMain=null；
静态int j=0；
静态无效显示开关（开关[]开关）
{
对于（int i=switches.Length-1；i>=0；i--）
{
Console.WriteLine（$”名称：{switches[i].Name}\t价格：{switches[i].value}\t”）；
}
返回；
}
静态异步任务GetSwitchesAsync（字符串路径）
{
开关[]开关=空；
responsemain=await client.GetAsync（路径）；
//WriteLine（client.GetAsync（path））；
//控制台写入线（响应）；
if（响应主要IsSuccessStatusCode）
{
//WriteLine（$“成功响应：{response.StatusCode}”）；
var response1=await client.GetStringAsync（“”）；
Console.WriteLine（$“{response1}”）；
switches=wait responsemain.Content.ReadAsAsync（）；
//JObject j=JObject.Parse（response1）；
}
else Console.WriteLine（$“响应错误：{responsemain.StatusCode}”）；
返回开关；
}
静态异步任务更新开关同步（开关）
{
控制台。写线（“关灯”）；
HttpResponseMessage response=等待客户端.PutAsJsonAsync（$“开关/关闭？房间=起居室”，开关）；
response.EnsureSuccessStatusCode（）；
Console.WriteLine（$“来自服务器的响应为：{response.StatusCode}”）；
//从响应主体反序列化更新的开关。
switches=wait response.Content.ReadAsAsync（）；
睡眠（10000）；
Console.WriteLine（$“打开灯”）；
response=wait client.PutAsJsonAsync（$“开关/打开？房间=起居室”，开关）；
Console.WriteLine（$“来自服务器的响应为：{response.StatusCode}”）；
睡眠（10000）；
返回开关；
}
静态异步任务DeleteSwitchesAsync（字符串id）
{
HttpResponseMessage response=await client.DeleteAsync（$“api/switchess/{id}”）；
返回response.StatusCode；
}
/// 
///帖子：api/Messages
///接收来自用户的消息并回复
/// 
公共异步任务发布（[FromBody]活动）
{
开关[]开关=空；
ConnectorClient连接器=新的ConnectorClient（新Uri（activity.ServiceUrl））；
//字符串appdId=AppSettings.Settings[“MicrosoftAppId”]；
//字符串appPassword=ConfigurationManager.AppSettings[“MicrosoftAppPassword”]；
如果（j==0）
{
//client.Timeout=TimeSpan.FromSeconds（4）；
//客户端和交换机变量的声明
字符串accessToken=“xxxxx”；
client.BaseAddress=新Uri（“xxxxx”）；
client.DefaultRequestHeaders.Accept.Clear（）；
client.DefaultRequestHeaders.Accept.Add（新的MediaTypeWithQualityHeaderValue（“应用程序/json”）；
client.DefaultRequestHeaders.Add（“授权”、“承载人”+accessToken）；
j++；
//client.DefaultRequestHeaders.Authorization=新的AuthenticationHeaderValue（“授权”、“承载人”+accessToken）；
}
if（activity.Type==ActivityTypes.Message）
{
//，appdId，appPassword）；
//开关=新开关；
Activity reply1；//=Activity.CreateReply（$“断点1”）；
//等待连接器.Conversations.ReplyToActivityAsync（reply1）；
开关（activity.Text.ToLower（））
{
案例“打开客厅”：
尝试
{
控制台。写线（“打开灯”）；
responsemain=wait client.PutAsJsonAsync（$“开关/打开？房间=起居室”，开关）；
responsemain.EnsureSuccessStatusCode（）；
//Console.WriteLine（$”来自服务器的响应是：{responsemain.StatusCode}”）；
//从响应主体反序列化更新的产品。
switches=wait responsemain.Content.ReadAsAsync（）；
reply1=activity.CreateReply（$“已成功打开客厅灯”）；
等待连接器.Conversations.ReplyToActivityAsync（reply1）；
}
抓住
{
reply1=activity.CreateReply（$“错误”）；
等待连接器.Conversations.ReplyToActivityAsync（reply1）；
}
打破
案例“关闭客厅”：
尝试
{
控制台。写线（“关灯”）；
响应main=aw