主页 / 问题 / 1588909
Accepted
Dev18
Asked:2024-07-30 21:34:47 +0000 UTC2024-07-30 21:34:47 +0000 UTC

如何管理 Web 应用程序会话以通过 API 挂钩更新两个会话？

  • 772

任务：根据 API 请求更新所有打开会话中的页面。当 API 发送请求时，两个会话都必须更新。例如，如果 Alice 和 Bob 打开页面，则两个页面都应该更新。

问题：目前，如果您打开第二个会话并且它离开页面 X，则第一个会话将失去其订阅并且不再接收更新。

状况：

  1. 第一个 Web 应用程序是在 Blazor Server 中编写的。
  2. 第二个是一个简单的 API 挂钩。

如何确保两个会话保持签名并接收更新，而不管用户在另一个会话中的操作如何？

挂钩API

public static readonly ConcurrentDictionary<string, string> Subscribers = new();

[HttpPost("subscribe")]
public IActionResult Subscribe([FromBody] SubscriptionRequest request)
{
    Subscribers[request.Url] = request.Url;
    return Ok(new { status = "subscribed" });
}

[HttpPost("unsubscribe")]
public IActionResult Unsubscribe([FromBody] SubscriptionRequest request)
{
    Subscribers.TryRemove(request.Url, out _);
    return Ok(new { status = "unsubscribed" });
}

private async Task<IActionResult> SendWebhookToSubscribers(IEnumerable<SimpleDataForHookTest> payload)
{
    var client = _httpClientFactory.CreateClient();
    foreach (var subscriber in Subscribers.Values)
    {
        await client.PostAsJsonAsync(subscriber, payload);
    }
    return Ok(new { status = "webhook sent" });
}

布拉佐尔

protected override async Task OnInitializedAsync()
{
    await SubscriptionService.Subscribe("https://localhost:7052/api/TestHook/TestWebHook");
    HookService.Register(ReceivePlanningData);
}

private void ReceivePlanningData(IEnumerable<SimpleDataForHookTest> planningListDto)
{
    MyPropertyTestHook = planningListDto;
    InvokeAsync(StateHasChanged);
}

public void Dispose()
{
    HookService.UnRegister(ReceivePlanningData);
    SubscriptionService.Unsubscribe("https://localhost:7052/api/TestHook/TestWebHook").GetAwaiter().GetResult();
}

完整的代码位于 GitHub 上（这里我分享了控制器和 Razor 页面的主要代码）。如果您运行这两个应用程序，则 15 秒后页面 1 会更新，但如果您并行打开页面 2 并保留它，则第一个页面将不再更新。

我试过：

a) Blazor 端的计时器每 n 分钟发出 GET 请求。这是昂贵的并且会在用户工作时破坏页面。

b) SignalR，虽然订阅成功了，但没有起作用，也不刷新页面。在 main 上有一个带有 SignalR 的版本，我无法修改它。

GitHub 上的工作分支：

（我通常使用Azure DevOps，我不知道是否需要在GitHub上创建拉取请求，或者我是否可以克隆。我通过Visual Studio创建了一个新分支并提交了它，但我找不到该选项在 GitHub 上创建拉取请求）。

也许有人有自己的想法，可以告诉我如何从 API 更新数据。数据如何到达 API 并不重要，但 API 将数据发送给订阅者（在此示例中为 Blazor Web）。

c#

1 个回答

  1. Best Answer

    如果在实现 SignalR 时向应用程序地址本身添加标识符，则可以获得每个会话的唯一链接，从而使每个连接都是唯一的。

    在此输入图像描述

    因此，使用SignalR，可以实现所有会话的更新，无论其中之一是否已离开订阅。

    挂钩API

    PlanningHub.cs

    using System.Collections.Concurrent;
using Microsoft.AspNetCore.SignalR;

namespace TestHookApiSimpleTest.Models
{
    public class PlanningHub : Hub
    {
        public static readonly ConcurrentDictionary<string, string> Subscribers = new();

        public override Task OnConnectedAsync()
        {
            Console.WriteLine($"Client connected: {Context.ConnectionId}");
            return base.OnConnectedAsync();
        }

        public override Task OnDisconnectedAsync(Exception? exception)
        {
            Subscribers.TryRemove(Context.ConnectionId, out _);
            Console.WriteLine($"Client disconnected: {Context.ConnectionId}");
            return base.OnDisconnectedAsync(exception);
        }

        public Task Subscribe(string url)
        {
            Subscribers[Context.ConnectionId] = url;
            Console.WriteLine($"Client subscribed: {Context.ConnectionId} with URL: {url}");
            return Task.CompletedTask;
        }

        public Task Unsubscribe()
        {
            Subscribers.TryRemove(Context.ConnectionId, out _);
            Console.WriteLine($"Client unsubscribed: {Context.ConnectionId}");
            return Task.CompletedTask;
        }

        public static IReadOnlyCollection<string> GetSubscribers()
        {
            return Subscribers.Values.ToList();
        }
    }
}

    EventController.cs

    using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.SignalR;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using TestHookApiSimpleTest.Models;

namespace TestHookApiSimpleTest.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class EventController : ControllerBase
    {
        private readonly IHttpClientFactory _httpClientFactory;
        private readonly IHubContext<PlanningHub> _hubContext;

        public EventController(IHttpClientFactory httpClientFactory, IHubContext<PlanningHub> hubContext)
        {
            _httpClientFactory = httpClientFactory;
            _hubContext = hubContext;
        }

        [HttpPost("planning")]
        public async Task<IActionResult> SendWebhook([FromBody] IEnumerable<SimpleDataForHookTest> payload)
        {
            return await SendWebhookToSubscribers(payload);
        }

        [HttpPost("subscribe")]
        public async Task<IActionResult> Subscribe([FromBody] SubscriptionRequest request)
        {
            await _hubContext.Clients.All.SendAsync("Subscribe", request.Url);
            return Ok(new { status = "subscribed" });
        }

        [HttpPost("unsubscribe")]
        public async Task<IActionResult> Unsubscribe([FromBody] SubscriptionRequest request)
        {
            await _hubContext.Clients.All.SendAsync("Unsubscribe");
            return Ok(new { status = "unsubscribed" });
        }

        private async Task<IActionResult> SendWebhookToSubscribers(IEnumerable<SimpleDataForHookTest> payload)
        {
            try
            {
                var subscribers = PlanningHub.GetSubscribers();

                var client = _httpClientFactory.CreateClient();
                foreach (var subscriber in subscribers)
                {
                    var response = await client.PostAsJsonAsync(subscriber, payload);
                    response.EnsureSuccessStatusCode();
                }

                return Ok(new { status = "webhook sent" });
            }
            catch (Exception ex)
            {
                return StatusCode(500, new { error = ex.Message });
            }
        }
    }
}

    布拉佐尔

    UpdateHub.cs

    using Microsoft.AspNetCore.SignalR;

namespace TestHook.Data
{
    public class UpdateHub : Hub
    {
        public async Task SendUpdate(IEnumerable<SimpleDataForHookTest> data)
        {
            await Clients.All.SendAsync("ReceiveUpdate", data);
        }
    }
}

    PageRazorExample.razor.cs

    using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.SignalR.Client;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using TestHook.Data;
using TestHook.Services;

namespace TestHook.Pages
{
    public partial class PageRazorExample : IAsyncDisposable
    {
        private List<SimpleDataForHookTest> updates;
        private HubConnection hubConnection;

        [Inject]
        public ISubscriptionService SubscriptionService { get; set; }

        [Inject]
        public IHookService HookService { get; set; }

        protected override async Task OnInitializedAsync()
        {
            hubConnection = new HubConnectionBuilder()
                .WithUrl(Navigation.ToAbsoluteUri("https://localhost:7006/planninghub"))
                .Build();

            hubConnection.On<IEnumerable<SimpleDataForHookTest>>("ReceiveUpdate", (data) =>
            {
                updates = data.ToList();
                InvokeAsync(StateHasChanged);
            });

            await hubConnection.StartAsync();
            await hubConnection.SendAsync("Subscribe", "https://localhost:7052/api/TestHook/TestWebHook");

            HookService.Register(ReceivePlanningData);
        }

        IEnumerable<SimpleDataForHookTest> MyPropertyTestHook { get; set; }

        private void ReceivePlanningData(IEnumerable<SimpleDataForHookTest> planningListDto)
        {
            if (planningListDto != null && planningListDto.Any())
            {
                MyPropertyTestHook = planningListDto;
                Console.WriteLine("Received planning data.");
                InvokeAsync(StateHasChanged);
            }
            else
            {
                Console.WriteLine("Not send data from hook");
            }
        }

        public async ValueTask DisposeAsync()
        {
            await hubConnection.SendAsync("Unsubscribe");
            HookService.UnRegister(ReceivePlanningData);
            await hubConnection.DisposeAsync();
        }
    }
}

    Program.cs

    ....
// Add SignalR services
builder.Services.AddSignalR();
...
app.MapHub<UpdateHub>("/updatehub");

    已测试：在多个会话中工作（Chrome 中的 1 个页面 + 通过 Ctrl+Shift+N 的 2 个页面）。刷新两个页面以重置 HTML，然后退出页面 2，页面 1 将继续刷新。

    • 0

相关问题