C# Online Compiler | .NET Fiddle

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

using Microsoft.Extensions.DependencyInjection;

using MediatR;

// Chat message request
public class ChatMessage : IRequest
{
    public string Sender { get; }
    public string Content { get; }

    public ChatMessage(string sender, string content)
    {
        Sender = sender;
        Content = content;
    }
}

// Chat message handler (MediatR creates a new instance
// every time it handles a message)
public class ChatMessageHandler : IRequestHandler<ChatMessage>
{
	private readonly UserRegistrar _userRegistrar;

    public ChatMessageHandler(UserRegistrar userRegistrar)
    {
		Console.WriteLine("Constructing chat message handler");
        _userRegistrar = userRegistrar;
    }

    public Task Handle(ChatMessage request, CancellationToken cancellationToken)
    {
	    Console.WriteLine("Entering message handler...");
		
		// NOTE: this code isn't thread-safe in that someone in the future
		// could be trying to register a user while we're enumerating
        foreach (var user in _userRegistrar.Users)
        {
            if (user.Name != request.Sender)
            {
                user.ReceiveMessage(request.Content, request.Sender);
            }
        }
		
		Console.WriteLine("Exiting message handler.");
        return Task.CompletedTask;
    }    
}

// we use this class to preserve the list of users
public class UserRegistrar
{
	private readonly List<ChatUser> _users;
	
	public UserRegistrar()
	{
		_users = new List<ChatUser>();
	}
	
	public IReadOnlyList<ChatUser> Users => _users;
	
	public void RegisterUser(ChatUser user)
    {
        _users.Add(user);
    }
}

// Chat user
public class ChatUser
{
    private readonly IMediator _mediator;
    
	public string Name { get; }

    public ChatUser(IMediator mediator, string name)
    {
        _mediator = mediator;
        this.Name = name;
    }

    public async Task SendMessage(string message)
    {
        await _mediator.Send(new ChatMessage(Name, message));
    }

    public void ReceiveMessage(string message, string sender)
    {
        Console.WriteLine($"{Name} received message from {sender}: {message}");
    }
}

// Program entry
public class Program
{
    public static async Task Main(string[] args)
    {
		Console.WriteLine("Creating services...");
        
		var services = new ServiceCollection();
		services.AddScoped<ChatMessageHandler>();
		services.AddSingleton<UserRegistrar>();
        services.AddMediatR(cfg =>
        {
            cfg.RegisterServicesFromAssemblies(typeof(Program).Assembly);
        });
        
        var serviceProvider = services.BuildServiceProvider();

        var mediator = serviceProvider.GetRequiredService<IMediator>();
        var handler = serviceProvider.GetRequiredService<ChatMessageHandler>();
		var userRegistrar = serviceProvider.GetRequiredService<UserRegistrar>();

        ChatUser user1 = new ChatUser(mediator, "User 1");
        ChatUser user2 = new ChatUser(mediator, "User 2");
        ChatUser user3 = new ChatUser(mediator, "User 3");

        userRegistrar.RegisterUser(user1);
        userRegistrar.RegisterUser(user2);
        userRegistrar.RegisterUser(user3);

		Console.WriteLine("Sending first message...");
        await user1.SendMessage("Hello, everyone!");
		
		Console.WriteLine("Sending second message...");
        await user1.SendMessage("Hello again, everyone!");
    }
}

 
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
​
using Microsoft.Extensions.DependencyInjection;
​
using MediatR;
​
// Chat message request
public class ChatMessage : IRequest
{
    public string Sender { get; }
    public string Content { get; }
​
    public ChatMessage(string sender, string content)
    {
        Sender = sender;
        Content = content;
    }
}
​
// Chat message handler (MediatR creates a new instance
// every time it handles a message)