JIT SignalR Hub Sending and Receiving

Question

Up till now for the past 3 months, I still have 0 clue how SignalR works at the JIT (Just-in-time) level. I'm trying to build a Hub that sends data to the client just in time, and the client will then receive the data and work along with it.

EDIT: Incase you have no idea what I mean by JIT Sending and Receiving,

I meant it by the server being able to send connected socket clients data when there is new data available. The socket connection will only be closed either when the server is shutdown/has an issue OR the client disconnects from the socket. So in short, no matter what, when new data arises from the server, it will always send that data ONE BY ONE to connection clients.

So here's what I'm missing out/confused about:

1. Is the SubscribeToAll (Check out TickerHub.cs below) Method the place where I call when I have new data to notify and beep to the clients or where is it?
2. I know how the asynchronous WriteToChannel works. Basically it sends a collection, item by item to the client. Key issue is, how do I convert this entire function to JIT? And where do I handle the list of clients subscribed to this hub?

Currently, TickerHub.cs keeps retrieving a dataset (named CurrencyPairs) and then broadcasts it to the clients indefinitely. I have a background service that syncs and updates the CurrencyPairs 24/7. I just need a SignalR expert's help to explain/show how I can invoke the Hub from the background service and then allow the hub to broadcast that new data to the connected clients.

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

In case you want to find out if my client sided code doesn't work well, here it is

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://learn.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; }
    }
}