Ищу удобный подход

    public interface IMessageService
    {
        event EventHandler<NotifyDictionaryChangedEventArgs<Guid, MessageDto>> MessagesChanged;
 
        IReadOnlyDictionary<Guid, MessageDto> Messages { get; }
 
        void SendMessage(Guid guid, string username, string message);
        Task SendMessageAsync(Guid guid, string username, string message);
    }

    internal abstract partial class MessageServiceAbstract : IMessageService
    {
        public event EventHandler<NotifyDictionaryChangedEventArgs<Guid, MessageDto>> MessagesChanged;
 
        private int messagesChangedSyncNumber = 0;
 
        protected void RaiseMessagesChangedEvent(NotifyDictionaryChangedAction action, MessageDto newMessage = null, MessageDto oldMessage = null)
        {
            // ...
        }
 
        protected void RaiseMessagesChangedEvent(IDictionary<Guid, MessageDto> newElements)
        {
            // ...
        }
    }

    internal abstract partial class MessageServiceAbstract
    {
        private readonly Dictionary<Guid, MessageDto> messages = new Dictionary<Guid, MessageDto>();
 
        public IReadOnlyDictionary<Guid, MessageDto> Messages { get; }
 
        public MessageServiceAbstract()
        {
            Messages = new ReadOnlyDictionary<Guid, MessageDto>(messages);
        }
    }

    internal abstract partial class MessageServiceAbstract : IMessageService
    {
        public abstract void SendMessage(Guid guid, string username, string message);
 
        public abstract Task SendMessageAsync(Guid guid, string username, string message);
    }

    internal class MessageServiceGrpc : MessageServiceAbstract, IMessageService
    {
        // ...
    }

AbstractMessanger.MessangerServiceAbstract service = new WCFMessangerModel.MessangerService();
AbstractMessanger.MessangerServiceAbstract service = new gRPCMessangerModel.MessangerService();

public abstract MessangerServiceWithInitializeAbstract : MessangerServiceAbstract
{
    public abstract void Initialize();
}

public class SomeService : ISomeService
{
    public SomeDto GetSome(int id)
    {
        ....
    }
 
    public void CreateSome(SomeDto some)
    {
        ....
    }
}

var someDto = _someService.GetSome(42);

protected void RaiseMessagesChanged(Action action, MessageDto newMessage, MessageDto oldMessage = null)
{
    if(action == Action.Add)
        messages.Add(newMessage);
 
    MessgaseChanged?.Invoke(...);
}

private async Task RemoveItemAsync(SomeTypeDto someObject)
{
    var res = await _client.Remove(someObject.ToSomeType());
  
    if(res.IsSuccessful)
    {
        Items.Remove(someObject);
        RaiseItemsChanged(Action.Removed, someObject);
    }
}