Can a SignalR Hub receive events from clients? And if so, how?

Question

I have a signalR hub that needs to be able to receive an event from a client and then notify all other clients connected to the hub.

Is that possible?

I want my 'hub' application to be able to receive messages and send them. I can only figure out how to do the sending of messages. Here is what I have now:

Application 1-- Hub

Startup class:

  public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

            services.AddSignalR().AddHubOptions<EventsHub>(options =>
            {
                options.HandshakeTimeout = TimeSpan.FromMinutes(5);
                options.EnableDetailedErrors = true;
            });
            services.AddTransient(typeof(BusinessLogic.EventsBusinessLogic));          
        }

        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });

            app.UseSignalR((configure) =>
            {
                configure.MapHub<EventsHub>("/hubs/events", (options) =>
                {
                });
            });          
        }

Set Up of the Hub in Application 1

 public class EventsHub : Hub
    {
        public EventsHub()
        {
        }

        public override Task OnConnectedAsync()
        {
            if (UserHandler.ConnectedIds.Count == 0)
            {
                //Do something on connect
            }
            UserHandler.ConnectedIds.Add(Context.ConnectionId);
            Console.WriteLine("Connection:");
            return base.OnConnectedAsync();
        }

        public override async Task OnDisconnectedAsync(Exception exception)
        {
          //Do something on Disconnect

        }


        public static class UserHandler
        {
            public static HashSet<string> ConnectedIds = new HashSet<string>();
        }
    }

BusinessLogic:

    public class EventsBusinessLogic
    {
        private readonly IHubContext<EventsHub> _eventsHub;

        public EventsBusinessLogic(IHubContext<EventsHub> eventsHub)
        {
            _eventsHub = eventsHub;                       
        }

        public async Task<Task> EventReceivedNotification(ProjectMoonEventLog eventInformation)
        {
            try
            {             
                 await _eventsHub.Clients.All.SendAsync("NewEvent", SomeObject);        
            }
            catch (Exception e)
            {

                throw new Exception(e.Message);
            }
        }
    }

In the second application, that listens for events or messages from the hub:

Startup.cs

  private static void ConfigureAppServices(IServiceCollection services, string Orale, string Sql)
        {
            services.Configure<CookiePolicyOptions>(options =>
            {
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });

            services.AddOptions();

            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

            //set up of singletons and transients

            services.AddHostedService<Events.EventingHubClient>();
        }

The ClientHub to connect to application 1:

public class EventingHubClient : IHostedService
    {
        private HubConnection _connection;

        public EventingHubClient()
        {

            _connection = new HubConnectionBuilder()
                .WithUrl("http://localhost:61520/hubs/events")
                .Build();


            _connection.On<Event>("NewEvent",
    data => _ = EventReceivedNotification(data));

        }

        public async Task<Task> EventReceivedNotification(Event eventInformation)
        {
            try
            {


              //Do something when the event happens     

                return Task.CompletedTask;
            }
            catch (Exception e)
            {

                throw new Exception(e.Message);
            }

        }


        public async Task StartAsync(CancellationToken cancellationToken)
        {
            // Loop is here to wait until the server is running
            while (true)
            {
                try
                {
                    await _connection.StartAsync(cancellationToken);
                    Console.WriteLine("Connected");
                    break;
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                    await Task.Delay(100);
                }
            }
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            return _connection.DisposeAsync();
        }

    }

This works, but now I want application 2 to be able to send a message to application 1? So I need a similar piece of code as in the EventsBusinessLogic class in application2 to send messages to application 1.

I hope this is clear enough? Is this the purpose of SignalR?

Answer 1

Please refer to signalR documentation signalR documentation for .net client

I guess in your Hub method like this

public async Task SendTransaction(Transaction data)
{
    await Clients.All.SendAsync("TransactionReceived", data);
}

Then add methods in client side

in constructor add

 connection.On<Transaction>("TransactionReceived", (data) =>
    {
        this.Dispatcher.Invoke(() =>
        {
           var transactionData = data;
        });
        });

and then SendTransaction expected on server

private async void SendTransaction(Transaction data)
{
    try
    {
        await connection.InvokeAsync("SendTransaction", data);
    }
    catch (Exception ex)
    {                
        // 
        throw
    }
}