try catch a lot

MareSynchronosServer/MareSynchronosServer/Services/GPoseLobbyDistributionService.cs

@@ -45,24 +45,44 @@ public sealed class GPoseLobbyDistributionService : IHostedService, IDisposable
     public async Task PushWorldData(string lobby, string user, WorldData worldData)
     {
         await _lobbyWorldDataModificationSemaphore.WaitAsync().ConfigureAwait(false);
+        try
+        {
             if (!_lobbyWorldData.TryGetValue(lobby, out var worldDataDict))
             {
                 _lobbyWorldData[lobby] = worldDataDict = new(StringComparer.Ordinal);
             }
             worldDataDict[user] = worldData;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during Pushing World Data for Lobby {lobby} by User {user}", lobby, user);
+        }
+        finally
+        {
             _lobbyWorldDataModificationSemaphore.Release();
         }
+    }
 
     public async Task PushPoseData(string lobby, string user, PoseData poseData)
     {
         await _lobbyPoseDataModificationSemaphore.WaitAsync().ConfigureAwait(false);
+        try
+        {
             if (!_lobbyPoseData.TryGetValue(lobby, out var poseDataDict))
             {
                 _lobbyPoseData[lobby] = poseDataDict = new(StringComparer.Ordinal);
             }
             poseDataDict[user] = poseData;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during Pushing World Data for Lobby {lobby} by User {user}", lobby, user);
+        }
+        finally
+        {
             _lobbyPoseDataModificationSemaphore.Release();
         }
+    }
 
     public Task StartAsync(CancellationToken cancellationToken)
     {
@@ -75,8 +95,15 @@ public sealed class GPoseLobbyDistributionService : IHostedService, IDisposable
     private async Task WorldDataDistribution(CancellationToken token)
     {
         while (!token.IsCancellationRequested)
+        {
+            try
             {
                 await DistributeWorldData(token).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error during World Data Distribution");
+            }
             await Task.Delay(TimeSpan.FromSeconds(1), token).ConfigureAwait(false);
         }
     }
@@ -84,8 +111,15 @@ public sealed class GPoseLobbyDistributionService : IHostedService, IDisposable
     private async Task PoseDataDistribution(CancellationToken token)
     {
         while (!token.IsCancellationRequested)
+        {
+            try
             {
                 await DistributePoseData(token).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error during Pose Data Distribution");
+            }
             await Task.Delay(TimeSpan.FromSeconds(10), token).ConfigureAwait(false);
         }
     }
@@ -93,13 +127,29 @@ public sealed class GPoseLobbyDistributionService : IHostedService, IDisposable
     private async Task DistributeWorldData(CancellationToken token)
     {
         await _lobbyWorldDataModificationSemaphore.WaitAsync(token).ConfigureAwait(false);
-        var clone = _lobbyWorldData.ToDictionary(k => k.Key, k => k.Value, StringComparer.Ordinal);
+        Dictionary<string, Dictionary<string, WorldData>> clone = [];
+        try
+        {
+            clone = _lobbyWorldData.ToDictionary(k => k.Key, k => k.Value, StringComparer.Ordinal);
             _lobbyWorldData.Clear();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during Distributing World Data Clone generation");
+            _lobbyWorldData.Clear();
+            return;
+        }
+        finally
+        {
             _lobbyWorldDataModificationSemaphore.Release();
+        }
+
         foreach (var lobbyId in clone)
         {
             token.ThrowIfCancellationRequested();
 
+            try
+            {
                 if (!lobbyId.Value.Values.Any())
                     continue;
 
@@ -113,19 +163,40 @@ public sealed class GPoseLobbyDistributionService : IHostedService, IDisposable
                         .Client_GposeLobbyPushWorldData(new(data.Key), data.Value).ConfigureAwait(false);
                 }
             }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error during World Data Distribution for Lobby {lobby}", lobbyId.Key);
+                continue;
+            }
+        }
     }
 
     private async Task DistributePoseData(CancellationToken token)
     {
         await _lobbyPoseDataModificationSemaphore.WaitAsync(token).ConfigureAwait(false);
-        var clone = _lobbyPoseData.ToDictionary(k => k.Key, k => k.Value, StringComparer.Ordinal);
+        Dictionary<string, Dictionary<string, PoseData>> clone = [];
+        try
+        {
+            clone = _lobbyPoseData.ToDictionary(k => k.Key, k => k.Value, StringComparer.Ordinal);
             _lobbyPoseData.Clear();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during Distributing Pose Data Clone generation");
+            _lobbyPoseData.Clear();
+            return;
+        }
+        finally
+        {
             _lobbyPoseDataModificationSemaphore.Release();
+        }
 
         foreach (var lobbyId in clone)
         {
             token.ThrowIfCancellationRequested();
 
+            try
+            {
                 if (!lobbyId.Value.Values.Any())
                     continue;
 
@@ -139,6 +210,12 @@ public sealed class GPoseLobbyDistributionService : IHostedService, IDisposable
                         .Client_GposeLobbyPushPoseData(new(data.Key), data.Value).ConfigureAwait(false);
                 }
             }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error during Pose Data Distribution for Lobby {lobby}", lobbyId.Key);
+                continue;
+            }
+        }
     }
 
     public Task StopAsync(CancellationToken cancellationToken)