Enhances server user state consistency; upgrades C#

Refactors the `InMemoryRoomManager` to store only user IDs per connection,
ensuring that all user-specific operations consistently retrieve the
latest `User` object from the active `RoomState`. This prevents potential
desynchronization issues.

Upgrades the project to C# 13, enabling new language features and adopting
modern collection expression syntax. Removes direct user update calls from
client view models and adjusts available voting options.

Author: Keboo

Directory.Build.props

@@ -2,6 +2,7 @@
   <PropertyGroup>
     <Nullable>enable</Nullable>
     <ImplicitUsings>enable</ImplicitUsings>
+    <LangVersion>13</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

PointerStar/Client/Components/UserDialog.razor

@@ -47,8 +47,8 @@
     private void Submit() => MudDialog?.Close(DialogResult.Ok(ViewModel));
     private void Cancel() => MudDialog?.Cancel();
 
-    protected override async Task OnParametersSetAsync()
-    {
+    protected override async Task OnParametersSetAsync()
+    {
         await base.OnParametersSetAsync();
         ViewModel.Name = Name;
         ViewModel.SelectedRoleId = SelectedRoleId;

PointerStar/Client/ViewModels/UserDialogViewModel.cs

@@ -22,10 +22,6 @@ public UserDialogViewModel(HttpClient httpClient, IRoomHubConnection roomHubConn
     public void SelectRole(Role? role)
     {
         SelectedRoleId = role?.Id;
-        if(RoomHubConnection.IsConnected)
-        {
-            RoomHubConnection.UpdateUserAsync(new UserOptions { Name = Name, Role = role });
-        }
     }
 
     public async Task LoadRoomDataAsync(string? roomId)

PointerStar/Server/Room/InMemoryRoomManager.cs

@@ -6,12 +6,12 @@ public class InMemoryRoomManager : IRoomManager
     private ConcurrentDictionary<string, SemaphoreSlim> RoomLocks { get; } = new();
     private ConcurrentDictionary<string, RoomState> Rooms { get; } = new();
     private ConcurrentDictionary<string, string> ConnectionsToRoom { get; } = new();
-    private ConcurrentDictionary<string, User> ConnectionsToUser { get; } = new();
+    private ConcurrentDictionary<string, Guid> ConnectionsToUserId { get; } = new();
 
     public Task<RoomState> AddUserToRoomAsync(string roomId, User user, string connectionId)
     {
         ConnectionsToRoom.AddOrUpdate(connectionId, roomId, (_, _) => roomId);
-        ConnectionsToUser.AddOrUpdate(connectionId, user, (_, _) => user);
+        ConnectionsToUserId.AddOrUpdate(connectionId, user.Id, (_, _) => user.Id);
 
         if (user.Name.Length > User.MaxNameLength)
         {
@@ -21,14 +21,14 @@ public Task<RoomState> AddUserToRoomAsync(string roomId, User user, string conne
         return WithRoomLock(roomId, () =>
         {
             RoomState rv = Rooms.AddOrUpdate(roomId,
-                new RoomState(roomId, new[] { user }),
+                new RoomState(roomId, [user]),
             (_, roomState) =>
             {
                 return roomState with
                 {
-                    Users = roomState.Users
+                    Users = [..roomState.Users
                         .Where(u => u.Id != user.Id)
-                        .Append(user).ToArray()
+                        .Append(user)]
                 };
             });
             return Task.FromResult(rv);
@@ -40,8 +40,8 @@ public Task<RoomState> AddUserToRoomAsync(string roomId, User user, string conne
     {
         return WithConnection(connectionId, (room, currentUser) =>
         {
-            User[] users = room.Users.Where(x => x.Id != currentUser.Id).ToArray();
-            if (users.Any())
+            User[] users = [..room.Users.Where(x => x.Id != currentUser.Id)];
+            if (users.Length != 0)
             {
                 return room with { Users = users };
             }
@@ -83,7 +83,7 @@ public Task<RoomState> AddUserToRoomAsync(string roomId, User user, string conne
     {
         return WithConnection(connectionId, (room, currentUser) =>
         {
-            User[] users = room.Users.Select(x =>
+            User[] users = [..room.Users.Select(x =>
             {
                 if (x.Id == currentUser.Id)
                 {
@@ -101,7 +101,7 @@ public Task<RoomState> AddUserToRoomAsync(string roomId, User user, string conne
                     }
                 }
                 return x;
-            }).ToArray();
+            })];
             return room with { Users = users };
         });
     }
@@ -116,11 +116,11 @@ public Task<RoomState> AddUserToRoomAsync(string roomId, User user, string conne
             }
             var roomState = room with
             {
-                Users = room.Users.Select(u => u.Id == currentUser.Id ? u with
+                Users = [..room.Users.Select(u => u.Id == currentUser.Id ? u with
                 {
                     OriginalVote = room.VotesShown ? u.OriginalVote : vote,
                     Vote = vote
-                } : u).ToArray()
+                } : u)]
             };
 
             if (ShouldShowVotes(roomState))
@@ -187,20 +187,21 @@ public Task<Role> GetNewUserRoleAsync(string roomId)
     private Task<RoomState?> WithConnection(string connectionId, Func<RoomState, User, RoomState?> updateRoom)
     {
         if (ConnectionsToRoom.TryGetValue(connectionId, out string? roomId) &&
-            ConnectionsToUser.TryGetValue(connectionId, out User? user))
+            ConnectionsToUserId.TryGetValue(connectionId, out Guid userId))
         {
-            return WithExistingRoom(roomId, room => updateRoom(room, user));
+            return WithExistingRoom(roomId, userId, (room, user) => updateRoom(room, user));
         }
         return Task.FromResult<RoomState?>(null);
     }
 
-    private Task<RoomState?> WithExistingRoom(string roomId, Func<RoomState, RoomState?> updateRoom)
+    private Task<RoomState?> WithExistingRoom(string roomId, Guid userId, Func<RoomState, User, RoomState?> updateRoom)
     {
         return WithRoomLock(roomId, () =>
         {
-            if (Rooms.TryGetValue(roomId, out RoomState? existingRoom))
+            if (Rooms.TryGetValue(roomId, out RoomState? existingRoom) &&
+                existingRoom.Users.SingleOrDefault(x => x.Id == userId) is { } user)
             {
-                RoomState? updatedRoom = updateRoom(existingRoom);
+                RoomState? updatedRoom = updateRoom(existingRoom, user);
                 if (updatedRoom is not null)
                 {
                     if (Rooms.TryUpdate(roomId, updatedRoom, existingRoom))

PointerStar/Shared/RoomState.cs

@@ -3,13 +3,13 @@
 public record class RoomState(string RoomId, User[] Users)
 {
     public IReadOnlyList<User> TeamMembers
-        => Users.Where(u => u.Role == Role.TeamMember).ToList();
+        => [.. Users.Where(u => u.Role == Role.TeamMember)];
 
     public IReadOnlyList<User> Facilitators
-        => Users.Where(u => u.Role == Role.Facilitator).ToList();
+        => [.. Users.Where(u => u.Role == Role.Facilitator)];
 
     public IReadOnlyList<User> Observers
-        => Users.Where(u => u.Role == Role.Observer).ToList();
+        => [.. Users.Where(u => u.Role == Role.Observer)];
 
     public bool VotesShown { get; init; }
     //We want the default to be true so new facilitators have this on by default
@@ -24,9 +24,6 @@ public IReadOnlyList<User> Observers
         "8",
         "13",
         "21",
-        "34",
-        "55",
-        "89",
         "Abstain",
         "?"
     };