Fix InconsistentStateException, Closes #813

backend/src/Squidex.Infrastructure.MongoDb/MongoDb/MongoExtensions.cs

@@ -132,11 +132,11 @@ namespace Squidex.Infrastructure.MongoDb
                 {
                     var field = Field.Of<T>(x => nameof(x.Version));
 
-                    throw new InconsistentStateException(existingVersion[field].AsInt64, oldVersion, ex);
+                    throw new InconsistentStateException(existingVersion[field].AsInt64, oldVersion);
                 }
                 else
                 {
-                    throw new InconsistentStateException(EtagVersion.Any, oldVersion, ex);
+                    throw new InconsistentStateException(EtagVersion.Any, oldVersion);
                 }
             }
         }

backend/src/Squidex.Infrastructure/Orleans/LoggingFilter.cs

@@ -6,6 +6,7 @@
 // ==========================================================================
 
 using Orleans;
+using Squidex.Infrastructure.States;
 using Squidex.Log;
 
 namespace Squidex.Infrastructure.Orleans
@@ -37,7 +38,6 @@ namespace Squidex.Infrastructure.Orleans
             catch (Exception ex)
             {
                 Log(context, ex);
-
                 throw;
             }
         }

backend/src/Squidex.Infrastructure/States/InconsistentStateException.cs

@@ -12,37 +12,35 @@ namespace Squidex.Infrastructure.States
     [Serializable]
     public class InconsistentStateException : Exception
     {
-        public long CurrentVersion { get; }
+        public long VersionCurrent { get; }
 
-        public long ExpectedVersion { get; }
+        public long VersionExpected { get; }
 
-        public InconsistentStateException(long currentVersion, long expectedVersion, Exception? inner = null)
+        public InconsistentStateException(long current, long expected, Exception? inner = null)
-            : base(FormatMessage(currentVersion, expectedVersion), inner)
+            : base(FormatMessage(current, expected), inner)
         {
-            CurrentVersion = currentVersion;
+            VersionCurrent = current;
-
+            VersionExpected = expected;
-            ExpectedVersion = expectedVersion;
         }
 
         protected InconsistentStateException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
-            CurrentVersion = info.GetInt64(nameof(CurrentVersion));
+            VersionCurrent = info.GetInt64(nameof(VersionCurrent));
-
+            VersionExpected = info.GetInt64(nameof(VersionExpected));
-            ExpectedVersion = info.GetInt64(nameof(ExpectedVersion));
         }
 
         public override void GetObjectData(SerializationInfo info, StreamingContext context)
         {
-            info.AddValue(nameof(CurrentVersion), CurrentVersion);
+            info.AddValue(nameof(VersionCurrent), VersionCurrent);
-            info.AddValue(nameof(ExpectedVersion), ExpectedVersion);
+            info.AddValue(nameof(VersionExpected), VersionExpected);
 
             base.GetObjectData(info, context);
         }
 
-        private static string FormatMessage(long currentVersion, long expectedVersion)
+        private static string FormatMessage(long current, long expected)
         {
-            return $"Requested version {expectedVersion}, but found {currentVersion}.";
+            return $"Requested version {expected}, but found {current}.";
         }
     }
 }

backend/tests/Squidex.Infrastructure.Tests/States/InconsistentStateExceptionTests.cs

@@ -22,8 +22,8 @@ namespace Squidex.Infrastructure.States
 
             Assert.Equal("Inner", result.InnerException?.Message);
 
-            Assert.Equal(result.ExpectedVersion, source.ExpectedVersion);
+            Assert.Equal(result.VersionExpected, source.VersionExpected);
-            Assert.Equal(result.CurrentVersion, source.CurrentVersion);
+            Assert.Equal(result.VersionCurrent, source.VersionCurrent);
 
             Assert.Equal(result.Message, source.Message);
         }