Question

到目前为止，在过去的3个月中，我仍然对SignalR在JIT（即时）级别上的工作情况有0线索。我正在尝试构建一个集线器，该集线器可以将数据及时发送到客户端，然后客户端将接收数据并与之一起工作。

编辑：如果您不知道我所说的JIT发送和   接收中，

我的意思是服务器可以在有新数据可用时发送连接的套接字客户端数据。仅当服务器关闭/出现问题或客户端从套接字断开连接时，套接字连接才会关闭。简而言之，无论如何，当服务器中出现新数据时，它将始终一次将数据一次发送给连接客户端。

这就是我想念/困惑的地方：

SubscribeToAll（在下面查看TickerHub.cs）是我有新数据通知并向客户端发出蜂鸣声时呼叫的地方吗？
我知道异步WriteToChannel的工作方式。基本上，它逐项发送一个集合到客户端。关键问题是，如何将整个功能转换为JIT？在哪里可以订阅该中心的客户列表？

当前，TickerHub.cs会不断检索数据集（名为CurrencyPairs），然后将其无限期广播到客户端。我有一个后台服务，可以同步和更新CurrencyPairs 24/7。我只需要SignalR专家的帮助来解释/显示如何从后台服务调用集线器，然后允许集线器向连接的客户端广播新数据。

TickerHub.cs

public class TickerHub : Hub, ITickerHubClient
{
    private IEnumerable<CurrencyPair> _currencyPairs;
    private readonly ICurrencyPairService _cpService;

    public TickerHub(ICurrencyPairService cpService)
    {
        _cpService = cpService;
    }

    public async Task<NozomiResult<CurrencyPair>> Tickers(IEnumerable<CurrencyPair> currencyPairs = null)
    {
        var nozRes = new NozomiResult<CurrencyPair>()
        {
            Success = true,
            ResultType = NozomiResultType.Success,
            Data = currencyPairs
        };

        return nozRes;
    }

    // We can use this to return a payload
    public async Task<ChannelReader<NozomiResult<CurrencyPair>>> SubscribeToAll()
    {
        // Initialize an unbounded channel
        // 
        // Unbounded Channels have no boundaries, allowing the server/client to transmit
        // limitless amounts of payload. Bounded channels have limits and will tend to 
        // drop the clients after awhile.
        var channel = Channel.CreateUnbounded<NozomiResult<CurrencyPair>>();

        _ = WriteToChannel(channel.Writer); // Write all Currency Pairs to the channel

        // Return the reader
        return channel.Reader;

        // This is a nested method, allowing us to write repeated methods
        // with the same semantic conventions while maintaining conformity.
        async Task WriteToChannel(ChannelWriter<NozomiResult<CurrencyPair>> writer)
        {
            // Pull in the latest data
            _currencyPairs = _cpService.GetAllActive();

            // Iterate them currency pairs
            foreach (var cPair in _currencyPairs)
            {
                // Write one by one, and the client receives them one by one as well
                await writer.WriteAsync(new NozomiResult<CurrencyPair>()
                {
                    Success = (cPair != null),
                    ResultType = (cPair != null) ? NozomiResultType.Success : NozomiResultType.Failed,
                    Data = new[] {cPair}
                });
            }

            // Beep the client, telling them you're done
            writer.Complete();
        }
    }
}

如果您想了解我的客户端代码是否运行不正常，请在此处

using Microsoft.AspNetCore.SignalR.Client;
using Newtonsoft.Json;
using Nozomi.Client.Data.Interfaces;
using Nozomi.Data;
using Nozomi.Data.CurrencyModels;
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Nozomi.Client
{
    public class NozomiClient
    {
        private CancellationToken _tickerStreamCancellationToken;
        private string ServerPath;
        private HubConnection _hubConnection;

        public NozomiClient(string serverPath)
        {
            ServerPath = serverPath;
            _hubConnection = new HubConnectionBuilder()
                .WithUrl(serverPath)
                .Build();
        }

        public async Task InitializeAsync()
        {
            await _hubConnection.StartAsync();
        }

        public async Task StreamTickers()
        {
            // Setup the channel for streaming
            var streamTickerChannel = await _hubConnection.StreamAsChannelAsync<NozomiResult<CurrencyPair>>("SubscribeToAll", CancellationToken.None);

            // Setup the asynchronous data stream
            // https://docs.microsoft.com/en-us/aspnet/core/signalr/streaming?view=aspnetcore-2.1#net-client
            //while (await streamTickerChannel.WaitToReadAsync())
            //{
            //    while (streamTickerChannel.TryRead(out var cp))
            //    {
            //        Console.WriteLine(JsonConvert.SerializeObject(cp));
            //    }
            //}

            _hubConnection.On<CurrencyPair>("SubscribeToAll", cp =>
            {
                Console.WriteLine(cp);
            });

            while (!_tickerStreamCancellationToken.IsCancellationRequested)
            {
                if (await streamTickerChannel.WaitToReadAsync())
                {
                    while (streamTickerChannel.TryRead(out var cp))
                    {
                        Console.WriteLine(JsonConvert.SerializeObject(cp));
                    }
                }

                Console.WriteLine("Processing");
                Thread.Sleep(1000);
            }
        }

        public ICurrencyPair CurrencyPairs { get; }

        public ISource Sources { get; }
    }
}

JIT SignalR集线器发送和接收

0 个答案: