Construct a Easy Chat Server With gRPC in .Internet Core

public class ChatService : ChatServerBase

    personal readonly ILogger<ChatService> _logger;

    public ChatService(ILogger<ChatService> logger)
    
        _logger = logger;
    

    public override Process HandleCommunication(IAsyncStreamReader<ClientMessage> requestStream, IServerStreamWriter<ServerMessage> responseStream, ServerCallContext context)
    
        return base.HandleCommunication(requestStream, responseStream, context);
    

utilizing ChatServer.Providers;
utilizing Microsoft.AspNetCore.Server.Kestrel.Core;

var builder = WebApplication.CreateBuilder(args);


/*
// Further configuration is required to efficiently run gRPC on macOS.
// For directions on methods to configure Kestrel and gRPC purchasers on macOS,
// go to https://go.microsoft.com/fwlink/?linkid=2099682

   To keep away from lacking ALPN help situation on Mac. To work round this situation, configure Kestrel and the gRPC consumer to make use of HTTP/2 with out TLS.
   It is best to solely do that throughout improvement. Not utilizing TLS will end in gRPC messages being despatched with out encryption.
   
   https://be taught.microsoft.com/en-us/aspnet/core/grpc/troubleshoot?view=aspnetcore-7.0
*/
builder.WebHost.ConfigureKestrel(choices =>

    // Setup a HTTP/2 endpoint with out TLS.
    choices.ListenLocalhost(50051, o => o.Protocols =
        HttpProtocols.Http2);
);


// Add companies to the container.
builder.Providers.AddGrpc();
builder.Providers.AddSingleton<ChatRoomService>();

var app = builder.Construct();

// Configure the HTTP request pipeline.
app.MapGrpcService<ChatService>();
app.MapGet("https://dzone.com/", () => "Communication with gRPC endpoints have to be made by a gRPC consumer. To discover ways to create a consumer, go to: https://go.microsoft.com/fwlink/?linkid=2086909");

Console.WriteLine($"gRPC server about to listening on port:50051");

app.Run();

utilizing System;
utilizing ChatServer;
utilizing Grpc.Core;
utilizing System.Collections.Concurrent;

namespace ChatServer.Providers
{
    public class ChatRoomService
    {
        personal static readonly ConcurrentDictionary<string, Record<ChatClient>> _chatRooms = new ConcurrentDictionary<string, Record<ChatClient>>();

        /// <abstract>
        /// Learn a single message from the consumer.
        /// </abstract>
        /// <exception cref="ConnectionLostException"></exception>
        /// <exception cref="TimeoutException"></exception>
        public async Process<ClientMessage> ReadMessageWithTimeoutAsync(IAsyncStreamReader<ClientMessage> requestStream, TimeSpan timeout)
        
            CancellationTokenSource cancellationTokenSource = new();

            cancellationTokenSource.CancelAfter(timeout);

            attempt
            
                bool moveNext = await requestStream.MoveNext(cancellationTokenSource.Token);

                if (moveNext == false)
                
                    throw new Exception("connection dropped exception");
                

                return requestStream.Present;
            
            catch (RpcException ex) when (ex.StatusCode == StatusCode.Cancelled)
            
                throw new TimeoutException();
            
        

        /// <abstract>
        /// <abstract>
        /// </abstract>
        /// <param title="chatRoomId"></param>
        /// <param title="person"></param>
        /// <returns></returns>

        public async Process AddClientToChatRoom(string chatRoomId, ChatClient chatClient)
        
            if (!_chatRooms.ContainsKey(chatRoomId))
            
                _chatRooms[chatRoomId] = new Record<ChatClient>  chatClient ;
            
            else
            
                var existingUser = _chatRooms[chatRoomId].FirstOrDefault(c => c.UserName == chatClient.UserName);
                if (existingUser != null)
                
                    // A person with the identical person title already exists within the chat room
                    throw new InvalidOperationException("Consumer with the identical title already exists within the chat room");
                
                _chatRooms[chatRoomId].Add(chatClient);
            

            await Process.CompletedTask;
        
        /// <abstract>
        /// Broad consumer joined the room message.
        /// </abstract>
        /// <param title="userName"></param>
        /// <param title="chatRoomId"></param>
        /// <returns></returns>
        public async Process BroadcastClientJoinedRoomMessage(string userName, string chatRoomId)
        
            if (_chatRooms.ContainsKey(chatRoomId))
            
                var message = new ServerMessage  UserJoined = new ServerMessageUserJoined  UserName = userName  ;

                var duties = new Record<Process>();

                foreach (var stream in _chatRooms[chatRoomId])
                
                    if (stream != null && stream != default)
                    
                        duties.Add(stream.StreamWriter.WriteAsync(message));
                    
                

                await Process.WhenAll(duties);
            
        

        /// <abstract>
        /// </abstract>
        /// <param title="chatRoomId"></param>
        /// <param title="senderName"></param>
        /// <param title="textual content"></param>
        /// <returns></returns>
        public async Process BroadcastMessageToChatRoom(string chatRoomId, string senderName, string textual content)
        
            if (_chatRooms.ContainsKey(chatRoomId))
            
                var message = new ServerMessage  Chat = new ServerMessageChat  UserName = senderName, Textual content = textual content  ;

                var duties = new Record<Process>();
                var streamList = _chatRooms[chatRoomId];
                foreach (var stream in _chatRooms[chatRoomId])
                
                    //This senderName will be one thing of distinctive Id for every person.
                    if (stream != null && stream != default && stream.UserName != senderName)
                    
                        duties.Add(stream.StreamWriter.WriteAsync(message));
                    
                

                await Process.WhenAll(duties);
            
        
    }

    public class ChatClient
    
        public IServerStreamWriter<ServerMessage> StreamWriter  get; set; 
        public string UserName  get; set; 
    
}

utilizing System;
utilizing ChatServer;
utilizing Grpc.Core;

namespace ChatServer.Providers
{
    public class ChatService : ChatServer.ChatServerBase
    {
        personal readonly ILogger<ChatService> _logger;
        personal readonly ChatRoomService _chatRoomService;

        public ChatService(ChatRoomService chatRoomService, ILogger<ChatService> logger)
        
            _chatRoomService = chatRoomService;
            _logger = logger;
        

        public override async Process HandleCommunication(IAsyncStreamReader<ClientMessage> requestStream, IServerStreamWriter<ServerMessage> responseStream, ServerCallContext context)
        {
            var userName = string.Empty;
            var chatRoomId = string.Empty;
            
            whereas (true)
             {
                //Learn a message from the consumer.
                var clientMessage = await _chatRoomService.ReadMessageWithTimeoutAsync(requestStream, Timeout.InfiniteTimeSpan);

                swap (clientMessage.ContentCase)
                
                    case ClientMessage.ContentOneofCase.Login:

                        var loginMessage = clientMessage.Login;
                        //get username and chatRoom Id from clientMessage.
                        chatRoomId = loginMessage.ChatRoomId;
                        userName = loginMessage.UserName;

                        if (string.IsNullOrEmpty(userName) 
            }
        }
    }
}