refactor: 重構 Usecase，將查改進行分離

Application/Common/IRepository.cs

@@ -11,6 +11,14 @@ public interface IRepository
     public string Save(Monopoly monopoly);
 }
 
+public interface ICommandRepository : IRepository
+{
+}
+
+public interface IQueryRepository : IRepository
+{
+}
+
 internal static class RepositoryExtensions
 {
     internal static string Save(this IRepository repository, Domain.Monopoly domainMonopoly)

Application/Common/Usecase.cs

@@ -2,10 +2,24 @@
 
 namespace Application.Common;
 
-public abstract class Usecase<TRequest, TResponse>(IRepository repository)
+public abstract class Usecase<TRequest, TResponse>()
     where TRequest : Request where TResponse : Response
 {
-    protected IRepository Repository { get; } = repository;
+    public abstract Task ExecuteAsync(TRequest request, IPresenter<TResponse> presenter);
+}
+
+public abstract class CommandUsecase<TRequest, TResponse>(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : Usecase<TRequest, TResponse>()
+    where TRequest : Request where TResponse : Response
+{
+    protected ICommandRepository Repository { get; } = repository;
+    protected IEventBus<DomainEvent> EventBus { get; } = eventBus;
+}
+
+public abstract class QueryUsecase<TRequest, TResponse>(ICommandRepository repository)
+    where TRequest : Request
+{
+    protected ICommandRepository Repository { get; } = repository;
 
     public abstract Task ExecuteAsync(TRequest request, IPresenter<TResponse> presenter);
-}
+}

Application/DependencyInjection.cs

@@ -15,10 +15,10 @@ private static IServiceCollection AddUseCases(this IServiceCollection services)
     {
         var assembly = typeof(DependencyInjection).Assembly;
         var types = assembly.GetTypes();
-        var useCaseType = typeof(Usecase<,>);
+        var useCaseType = typeof(CommandUsecase<,>);
         var queryUsecaseType = typeof(QueryUsecase<,>);
 
-        foreach (var type in types.Where(t => t.BaseType?.IsGenericType is true))
+        foreach (var type in types.Where(t => t.BaseType?.IsGenericType is true && t.IsAbstract == false))
         {
             if (type.BaseType?.GetGenericTypeDefinition() == useCaseType)
             {

Application/Queries/GetReadyInfoUsecase.cs

@@ -10,12 +10,9 @@ public record ReadyInfo(Player[] Players, string HostId);
     public record Player(string PlayerId, bool IsReady, string? RoleId, int? LocationId);
 }
 
-public class GetReadyInfoUsecase : QueryUsecase<GetReadyInfoRequest, GetReadyInfoResponse>
+public class GetReadyInfoUsecase(ICommandRepository repository)
+    : QueryUsecase<GetReadyInfoRequest, GetReadyInfoResponse>(repository)
 {
-    public GetReadyInfoUsecase(IRepository repository) : base(repository)
-    {
-    }
-
     public override async Task ExecuteAsync(GetReadyInfoRequest request, IPresenter<GetReadyInfoResponse> presenter)
     {
         var game = Repository.FindGameById(request.GameId);

Application/Usecases/BidUsecase.cs

@@ -8,8 +8,8 @@ public record BidRequest(string GameId, string PlayerId, decimal BidPrice)
 
 public record BidResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class BidUsecase(IRepository repository)
-    : Usecase<BidRequest, BidResponse>(repository)
+public class BidUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<BidRequest, BidResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(BidRequest request, IPresenter<BidResponse> presenter)
     {

Application/Usecases/BuildHouseUsecase.cs

@@ -8,8 +8,8 @@ public record BuildHouseRequest(string GameId, string PlayerId)
 
 public record BuildHouseResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class BuildHouseUsecase(IRepository repository)
-    : Usecase<BuildHouseRequest, BuildHouseResponse>(repository)
+public class BuildHouseUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<BuildHouseRequest, BuildHouseResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(BuildHouseRequest request, IPresenter<BuildHouseResponse> presenter)
     {

Application/Usecases/ChooseDirectionUsecase.cs

@@ -8,8 +8,8 @@ public record ChooseDirectionRequest(string GameId, string PlayerId, string Dire
 
 public record ChooseDirectionResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class ChooseDirectionUsecase(IRepository repository)
-    : Usecase<ChooseDirectionRequest, ChooseDirectionResponse>(repository)
+public class ChooseDirectionUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<ChooseDirectionRequest, ChooseDirectionResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(ChooseDirectionRequest request, IPresenter<ChooseDirectionResponse> presenter)
     {

Application/Usecases/CreateGameUsecase.cs

@@ -9,8 +9,8 @@ public record CreateGameRequest(string HostId, string[] PlayerIds) : Request(nul
 
 public record CreateGameResponse(string GameId) : Response;
 
-public class CreateGameUsecase(IRepository repository)
-    : Usecase<CreateGameRequest, CreateGameResponse>(repository)
+public class CreateGameUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<CreateGameRequest, CreateGameResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(CreateGameRequest request, IPresenter<CreateGameResponse> presenter)
     {

Application/Usecases/EndAuctionUsecase.cs

@@ -8,8 +8,8 @@ public record EndAuctionRequest(string GameId, string PlayerId)
 
 public record EndAuctionResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class EndAuctionUsecase(IRepository repository)
-    : Usecase<EndAuctionRequest, EndAuctionResponse>(repository)
+public class EndAuctionUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<EndAuctionRequest, EndAuctionResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(EndAuctionRequest request, IPresenter<EndAuctionResponse> presenter)
     {

Application/Usecases/EndRoundUsecase.cs

@@ -8,8 +8,8 @@ public record EndRoundRequest(string GameId, string PlayerId)
 
 public record EndRoundResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class EndRoundUsecase(IRepository repository)
-    : Usecase<EndRoundRequest, EndRoundResponse>(repository)
+public class EndRoundUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<EndRoundRequest, EndRoundResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(EndRoundRequest request, IPresenter<EndRoundResponse> presenter)
     {

Application/Usecases/GameStartUsecase.cs

@@ -8,8 +8,8 @@ public record GameStartRequest(string GameId, string PlayerId)
 
 public record GameStartResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class GameStartUsecase(IRepository repository)
-    : Usecase<GameStartRequest, GameStartResponse>(repository)
+public class GameStartUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<GameStartRequest, GameStartResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(GameStartRequest request, IPresenter<GameStartResponse> presenter)
     {

Application/Usecases/MortgageUsecase.cs

@@ -8,8 +8,8 @@ public record MortgageRequest(string GameId, string PlayerId, string BlockId)
 
 public record MortgageResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class MortgageUsecase(IRepository repository)
-    : Usecase<MortgageRequest, MortgageResponse>(repository)
+public class MortgageUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<MortgageRequest, MortgageResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(MortgageRequest request, IPresenter<MortgageResponse> presenter)
     {

Application/Usecases/PayTollUsecase.cs

@@ -8,8 +8,8 @@ public record PayTollRequest(string GameId, string PlayerId)
 
 public record PayTollResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class PayTollUsecase(IRepository repository)
-    : Usecase<PayTollRequest, PayTollResponse>(repository)
+public class PayTollUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<PayTollRequest, PayTollResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(PayTollRequest request, IPresenter<PayTollResponse> presenter)
     {

Application/Usecases/PlayerBuyLandUsecase.cs

@@ -8,8 +8,8 @@ public record PlayerBuyLandRequest(string GameId, string PlayerId, string LandID
 
 public record PlayerBuyLandResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class PlayerBuyLandUsecase(IRepository repository)
-    : Usecase<PlayerBuyLandRequest, PlayerBuyLandResponse>(repository)
+public class PlayerBuyLandUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<PlayerBuyLandRequest, PlayerBuyLandResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(PlayerBuyLandRequest request, IPresenter<PlayerBuyLandResponse> presenter)
     {

Application/Usecases/PlayerPreparedUsecase.cs

@@ -8,8 +8,8 @@ public record PlayerPreparedRequest(string GameId, string PlayerId)
 
 public record PlayerPreparedResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class PlayerPreparedUsecase(IRepository repository)
-    : Usecase<PlayerPreparedRequest, PlayerPreparedResponse>(repository)
+public class PlayerPreparedUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<PlayerPreparedRequest, PlayerPreparedResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(PlayerPreparedRequest request, IPresenter<PlayerPreparedResponse> presenter)
     {

Application/Usecases/PlayerRollDiceUsecase.cs

@@ -8,8 +8,8 @@ public record PlayerRollDiceRequest(string GameId, string PlayerId)
 
 public record PlayerRollDiceResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class PlayerRollDiceUsecase(IRepository repository)
-    : Usecase<PlayerRollDiceRequest, PlayerRollDiceResponse>(repository)
+public class PlayerRollDiceUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<PlayerRollDiceRequest, PlayerRollDiceResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(PlayerRollDiceRequest request, IPresenter<PlayerRollDiceResponse> presenter)
     {

Application/Usecases/RedeemUsecase.cs

@@ -8,7 +8,8 @@ public record RedeemRequest(string GameId, string PlayerId, string BlockId)
 
 public record RedeemResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class RedeemUsecase(IRepository repository) : Usecase<RedeemRequest, RedeemResponse>(repository)
+public class RedeemUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<RedeemRequest, RedeemResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(RedeemRequest request, IPresenter<RedeemResponse> presenter)
     {

Application/Usecases/SelectRoleUsecase.cs

@@ -8,8 +8,8 @@ public record SelectRoleRequest(string GameId, string PlayerId, string roleId)
 
 public record SelectRoleResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class SelectRoleUsecase(IRepository repository)
-    : Usecase<SelectRoleRequest, SelectRoleResponse>(repository)
+public class SelectRoleUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<SelectRoleRequest, SelectRoleResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(SelectRoleRequest request, IPresenter<SelectRoleResponse> presenter)
     {

Application/Usecases/SelectRoomLocationUsecase.cs

@@ -8,8 +8,8 @@ public record SelectLocationRequest(string GameId, string PlayerId, int Location
 
 public record SelectLocationResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class SelectLocationUsecase(IRepository repository)
-    : Usecase<SelectLocationRequest, SelectLocationResponse>(repository)
+public class SelectLocationUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<SelectLocationRequest, SelectLocationResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(SelectLocationRequest request, IPresenter<SelectLocationResponse> presenter)
     {

Application/Usecases/SettlementUsecase.cs

@@ -8,8 +8,8 @@ public record SettlementRequest(string GameId, string PlayerId)
 
 public record SettlementResponse(IReadOnlyList<DomainEvent> Events) : CommandResponse(Events);
 
-public class SettlementUsecase(IRepository repository)
-    : Usecase<SettlementRequest, SettlementResponse>(repository)
+public class SettlementUsecase(ICommandRepository repository, IEventBus<DomainEvent> eventBus)
+    : CommandUsecase<SettlementRequest, SettlementResponse>(repository, eventBus)
 {
     public override async Task ExecuteAsync(SettlementRequest request, IPresenter<SettlementResponse> presenter)
     {

Client/Pages/TypedHubConnection.cs

@@ -7,24 +7,16 @@ internal class TypedHubConnection
 {
     private readonly HubConnection hubConnection;
 
-    public event PlayerJoinGameEventDelegate? PlayerJoinGameEventHandler;
-    public delegate void PlayerJoinGameEventDelegate(PlayerJoinGameEvent e);
     public event GetReadyInfoEventDelegate? GetReadyInfoEventHandler;
     public delegate void GetReadyInfoEventDelegate(GetReadyInfoEventArgs e);
     public event WelcomeEventDelegate? WelcomeEventHandler;
     public delegate void WelcomeEventDelegate(WelcomeEventArgs e);
 
     public TypedHubConnection(HubConnection hubConnection)
     {
-        hubConnection.On<PlayerJoinGameEvent>(nameof(PlayerJoinGameEvent), (e) => PlayerJoinGameEventHandler?.Invoke(e));
         hubConnection.On<GetReadyInfoEventArgs>("GetReadyInfoEvent", (e) => GetReadyInfoEventHandler?.Invoke(e));
         hubConnection.On<WelcomeEventArgs>("WelcomeEvent", (e) => WelcomeEventHandler?.Invoke(e));
         this.hubConnection = hubConnection;
     }
     public async Task GetReadyInfo() => await hubConnection.SendAsync("GetReadyInfo");
 }
-
-internal class PlayerJoinGameEvent : EventArgs
-{
-    public required string PlayerId { get; set; }
-}

Server/DependencyInjection.cs

@@ -1,18 +1,19 @@
-using System.Reflection;
-using Application.Common;
+using Application.Common;
 using Domain.Common;
 using Server.Common;
-using Server.Hubs;
 using Server.Presenters;
 using Server.Repositories;
+using System.Reflection;
 
 namespace Server;
 
 public static class DependencyInjection
 {
     public static IServiceCollection AddMonopolyServer(this IServiceCollection services)
     {
-        services.AddSingleton<IRepository, InMemoryRepository>()
+        var repository = new InMemoryRepository();
+        services.AddSingleton<ICommandRepository>(repository)
+                .AddSingleton<IQueryRepository>(repository)
                 .AddSingleton<IEventBus<DomainEvent>, MonopolyEventBus>()
                 .AddTransient(typeof(SignalrDefaultPresenter<>), typeof(SignalrDefaultPresenter<>));
         services.AddSignalREventHandlers();
@@ -22,7 +23,7 @@ public static IServiceCollection AddMonopolyServer(this IServiceCollection servi
     private static IServiceCollection AddSignalREventHandlers(this IServiceCollection services)
     {
         var handlers = Assembly.GetExecutingAssembly().GetTypes()
-            .Where(t => t is { IsClass: true, IsAbstract: false } 
+            .Where(t => t is { IsClass: true, IsAbstract: false }
                           && t.IsAssignableTo(typeof(IMonopolyEventHandler)))
             .ToList();
         foreach (var handler in handlers)

Server/Hubs/MonopolyHub.cs

@@ -5,14 +5,14 @@
 using Microsoft.AspNetCore.SignalR;
 using Server.Presenters;
 using SharedLibrary;
-using System.Security.Claims;
 using SharedLibrary.ResponseArgs.Monopoly;
 using SharedLibrary.ResponseArgs.ReadyRoom;
+using System.Security.Claims;
 
 namespace Server.Hubs;
 
 [Authorize]
-public class MonopolyHub(IRepository repository) : Hub<IMonopolyResponses>
+public class MonopolyHub(ICommandRepository repository) : Hub<IMonopolyResponses>
 {
     private const string Playerid = "PlayerId";
     private const string Gameid = "GameId";
@@ -38,7 +38,7 @@ await usecase.ExecuteAsync(
     public async Task PlayerBuyLand(string gameId, string userId, string blockId, PlayerBuyLandUsecase usecase, SignalrDefaultPresenter<PlayerBuyLandResponse> presenter)
     {
         await usecase.ExecuteAsync(
-            new PlayerBuyLandRequest(gameId, userId, blockId), 
+            new PlayerBuyLandRequest(gameId, userId, blockId),
             presenter
             );
     }

Server/MonopolyEventBus.cs

@@ -4,15 +4,10 @@
 
 namespace Server;
 
-internal class MonopolyEventBus : IEventBus<DomainEvent>
+internal class MonopolyEventBus(IEnumerable<IMonopolyEventHandler> handlers) : IEventBus<DomainEvent>
 {
-    private readonly Dictionary<Type, IMonopolyEventHandler> _handlers;
+    private readonly Dictionary<Type, IMonopolyEventHandler> _handlers = handlers.ToDictionary(h => h.EventType, h => h);
 
-    public MonopolyEventBus(IEnumerable<IMonopolyEventHandler> handlers)
-    {
-        _handlers = handlers.ToDictionary(h => h.EventType, h => h);
-    }
-
     public async Task PublishAsync(IEnumerable<DomainEvent> events)
     {
         foreach (var e in events)

Server/Repositories/InMemoryRepository.cs

@@ -3,7 +3,7 @@
 
 namespace Server.Repositories;
 
-public class InMemoryRepository : IRepository
+public class InMemoryRepository : ICommandRepository, IQueryRepository
 {
     private readonly Dictionary<string, Monopoly> Games = new();
 

Test/ServerTests/AcceptanceTests/CreateGameTest.cs

@@ -21,7 +21,7 @@ public void Setup()
     {
         server = new MonopolyTestServer();
         jwtTokenService = server.GetRequiredService<MockJwtTokenService>();
-        repository = server.GetRequiredService<IRepository>();
+        repository = server.GetRequiredService<IQueryRepository>();
         jwtBearerOptions = server.GetRequiredService<IOptionsMonitor<JwtBearerOptions>>().Get("Bearer");
     }
 

Test/ServerTests/AcceptanceTests/PlayerJoinGameTest.cs

@@ -3,9 +3,9 @@
 using Microsoft.Extensions.Options;
 using Server.DataModels;
 using SharedLibrary;
+using SharedLibrary.ResponseArgs.Monopoly;
 using System.Net.Http.Headers;
 using System.Net.Http.Json;
-using SharedLibrary.ResponseArgs.Monopoly;
 
 namespace ServerTests.AcceptanceTests;
 
@@ -22,7 +22,7 @@ public void Setup()
     {
         server = new MonopolyTestServer();
         jwtTokenService = server.GetRequiredService<MockJwtTokenService>();
-        repository = server.GetRequiredService<IRepository>();
+        repository = server.GetRequiredService<IQueryRepository>();
         jwtBearerOptions = server.GetRequiredService<IOptionsMonitor<JwtBearerOptions>>().Get("Bearer");
     }