Optimize the member save as part of the member login process, by-passing locking and audit steps and handling only the expected update properties (#19308)

AndyButland · Copilot · Migaroez · AndyButland · commit 127c6c4b5395 · 2025-05-20T15:27:42.000+01:00
* Optimize the member save as part of the member login process, by-passing locking and audit steps and handling only the expected update properties.

* Added unit test to verify new behaviour.

* Update src/Umbraco.Infrastructure/Security/MemberUserStore.cs

Co-authored-by: Copilot &lt;175728472+Copilot@users.noreply.github.com&gt;

* Updates from code review.

* Improved comments.

* Add state information to notification indicating whether a member is saved via only the update of login properties.

---------

Co-authored-by: Copilot &lt;175728472+Copilot@users.noreply.github.com&gt;
Co-authored-by: Migaroez &lt;geusens@gmail.com&gt;
diff --git a/src/Umbraco.Core/Persistence/Repositories/IMemberRepository.cs b/src/Umbraco.Core/Persistence/Repositories/IMemberRepository.cs
@@ -38,4 +38,11 @@ public interface IMemberRepository : IContentRepository<int, IMember>
     /// <param name="query"></param>
     /// <returns></returns>
     int GetCountByQuery(IQuery<IMember>? query);
+
+    /// <summary>
+    /// Saves only the properties related to login for the member, using an optimized, non-locking update.
+    /// </summary>
+    /// <param name="member">The member to update.</param>
+    /// <returns>Used to avoid the full save of the member object after a login operation.</returns>
+    Task UpdateLoginPropertiesAsync(IMember member) => Task.CompletedTask;
 }
diff --git a/src/Umbraco.Core/Services/IMemberService.cs b/src/Umbraco.Core/Services/IMemberService.cs
@@ -343,4 +343,11 @@ IEnumerable<IMember> FindMembersByDisplayName(
     ///     <see cref="IEnumerable{IMember}" />
     /// </returns>
     IEnumerable<IMember>? GetMembersByPropertyValue(string propertyTypeAlias, DateTime value, ValuePropertyMatchType matchType = ValuePropertyMatchType.Exact);
+
+    /// <summary>
+    /// Saves only the properties related to login for the member, using an optimized, non-locking update.
+    /// </summary>
+    /// <param name="member">The member to update.</param>
+    /// <returns>Used to avoid the full save of the member object after a login operation.</returns>
+    Task UpdateLoginPropertiesAsync(IMember member) => Task.CompletedTask;
 }
diff --git a/src/Umbraco.Core/Services/MemberService.cs b/src/Umbraco.Core/Services/MemberService.cs
@@ -820,6 +820,48 @@ public void Save(IEnumerable<IMember> members)
             scope.Complete();
         }
 
+        /// <inheritdoc/>
+        /// <remarks>
+        /// <para>
+        ///     Note that in this optimized member save operation for use in the login process, where we only handle login related
+        ///     properties, we aren't taking any locks. If we were updating "content" properties, that could have relations between each
+        ///     other, we should following what we do for documents and lock.
+        ///     But here we are just updating these system fields, and it's fine if they work in a "last one wins" fashion without locking.
+        /// </para>
+        /// <para>
+        ///      Note also that we aren't calling "Audit" here (as well as to optimize performance, this is deliberate, because this is not
+        ///      a full save operation on the member that we'd want to audit who made the changes via the backoffice or API; rather it's
+        ///      just the member logging in as themselves).
+        /// </para>
+        /// <para>
+        ///      We are though publishing notifications, to maintain backwards compatibility for any solutions using these for
+        ///      processing following a member login.
+        /// </para>
+        /// <para>
+        ///      These notification handlers will ensure that the records to umbracoLog are also added in the same way as they
+        ///      are for a full save operation.
+        /// </para>
+        /// </remarks>
+        public async Task UpdateLoginPropertiesAsync(IMember member)
+        {
+            EventMessages evtMsgs = EventMessagesFactory.Get();
+
+            using ICoreScope scope = ScopeProvider.CreateCoreScope();
+            var savingNotification = new MemberSavingNotification(member, evtMsgs);
+            savingNotification.State.Add("LoginPropertiesOnly", true);
+            if (scope.Notifications.PublishCancelable(savingNotification))
+            {
+                scope.Complete();
+                return;
+            }
+
+            await _memberRepository.UpdateLoginPropertiesAsync(member);
+
+            scope.Notifications.Publish(new MemberSavedNotification(member, evtMsgs).WithStateFrom(savingNotification));
+
+            scope.Complete();
+        }
+
         #endregion
 
         #region Delete
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberRepository.cs
@@ -848,5 +848,50 @@ protected override void PersistUpdatedItem(IMember entity)
         entity.ResetDirtyProperties();
     }
 
+    /// <inheritdoc/>
+    public async Task UpdateLoginPropertiesAsync(IMember member)
+    {
+        var updatedLastLoginDate = member.IsPropertyDirty(nameof(member.LastLoginDate));
+        var updatedSecurityStamp = member.IsPropertyDirty(nameof(member.SecurityStamp));
+        if (updatedLastLoginDate is false && updatedSecurityStamp is false)
+        {
+            return;
+        }
+
+        NPocoSqlExtensions.SqlUpd<MemberDto> GetMemberSetExpression(IMember member, NPocoSqlExtensions.SqlUpd<MemberDto> m)
+        {
+            var setExpression = new NPocoSqlExtensions.SqlUpd<MemberDto>(SqlContext);
+            if (updatedLastLoginDate)
+            {
+                setExpression.Set(x => x.LastLoginDate, member.LastLoginDate);
+            }
+
+            if (updatedSecurityStamp)
+            {
+                setExpression.Set(x => x.SecurityStampToken, member.SecurityStamp);
+            }
+
+            return setExpression;
+        }
+
+        member.UpdatingEntity();
+
+        Sql<ISqlContext> updateMemberQuery = Sql()
+            .Update<MemberDto>(m => GetMemberSetExpression(member, m))
+            .Where<MemberDto>(m => m.NodeId == member.Id);
+        await Database.ExecuteAsync(updateMemberQuery);
+
+        Sql<ISqlContext> updateContentVersionQuery = Sql()
+            .Update<ContentVersionDto>(m => m.Set(x => x.VersionDate, member.UpdateDate))
+            .Where<ContentVersionDto>(m => m.NodeId == member.Id && m.Current == true);
+        await Database.ExecuteAsync(updateContentVersionQuery);
+
+        OnUowRefreshedEntity(new MemberRefreshNotification(member, new EventMessages()));
+
+        _memberByUsernameCachePolicy.DeleteByUserName(CacheKeys.MemberUserNameCachePrefix, member.Username);
+
+        member.ResetDirtyProperties();
+    }
+
     #endregion
 }
diff --git a/src/Umbraco.Infrastructure/Security/MemberUserStore.cs b/src/Umbraco.Infrastructure/Security/MemberUserStore.cs
@@ -161,7 +161,7 @@ public override Task<IdentityResult> CreateAsync(
     }
 
     /// <inheritdoc />
-    public override Task<IdentityResult> UpdateAsync(
+    public override async Task<IdentityResult> UpdateAsync(
         MemberIdentityUser user,
         CancellationToken cancellationToken = default)
     {
@@ -189,9 +189,21 @@ public override Task<IdentityResult> UpdateAsync(
                 var isLoginsPropertyDirty = user.IsPropertyDirty(nameof(MemberIdentityUser.Logins));
                 var isTokensPropertyDirty = user.IsPropertyDirty(nameof(MemberIdentityUser.LoginTokens));
 
-                if (UpdateMemberProperties(found, user, out var updateRoles))
+                IReadOnlyList<string> propertiesUpdated = UpdateMemberProperties(found, user, out var updateRoles);
+
+                if (propertiesUpdated.Count > 0)
                 {
-                    _memberService.Save(found);
+                    // As part of logging in members we update the last login date, and, if concurrent logins are disabled, the security stamp.
+                    // If and only if we are updating these properties, we can avoid the overhead of a full save of the member with the associated
+                    // locking, property updates, tag handling etc., and make a more efficient update.
+                    if (UpdatingOnlyLoginProperties(propertiesUpdated))
+                    {
+                        await _memberService.UpdateLoginPropertiesAsync(found);
+                    }
+                    else
+                    {
+                        _memberService.Save(found);
+                    }
 
                     if (updateRoles)
                     {
@@ -222,15 +234,21 @@ public override Task<IdentityResult> UpdateAsync(
             }
 
             scope.Complete();
-            return Task.FromResult(IdentityResult.Success);
+            return IdentityResult.Success;
         }
         catch (Exception ex)
         {
-            return Task.FromResult(
-                IdentityResult.Failed(new IdentityError { Code = GenericIdentityErrorCode, Description = ex.Message }));
+            return IdentityResult.Failed(new IdentityError { Code = GenericIdentityErrorCode, Description = ex.Message });
         }
     }
 
+    private static bool UpdatingOnlyLoginProperties(IReadOnlyList<string> propertiesUpdated)
+    {
+        string[] loginPropertyUpdates = [nameof(MemberIdentityUser.LastLoginDateUtc), nameof(MemberIdentityUser.SecurityStamp)];
+        return (propertiesUpdated.Count == 2 && propertiesUpdated.ContainsAll(loginPropertyUpdates)) ||
+               (propertiesUpdated.Count == 1 && propertiesUpdated.ContainsAny(loginPropertyUpdates));
+    }
+
     /// <inheritdoc />
     public override Task<IdentityResult> DeleteAsync(
         MemberIdentityUser user,
@@ -681,9 +699,9 @@ public override Task SetTokenAsync(MemberIdentityUser user, string loginProvider
         return user;
     }
 
-    private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityUser, out bool updateRoles)
+    private IReadOnlyList<string> UpdateMemberProperties(IMember member, MemberIdentityUser identityUser, out bool updateRoles)
     {
-        var anythingChanged = false;
+        var updatedProperties = new List<string>();
         updateRoles = false;
 
         // don't assign anything if nothing has changed as this will trigger the track changes of the model
@@ -692,7 +710,7 @@ private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityU
             || (identityUser.LastLoginDateUtc.HasValue &&
                 member.LastLoginDate?.ToUniversalTime() != identityUser.LastLoginDateUtc.Value))
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.LastLoginDateUtc));
 
             // if the LastLoginDate is being set to MinValue, don't convert it ToLocalTime
             DateTime dt = identityUser.LastLoginDateUtc == DateTime.MinValue
@@ -706,14 +724,14 @@ private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityU
             || (identityUser.LastPasswordChangeDateUtc.HasValue && member.LastPasswordChangeDate?.ToUniversalTime() !=
                 identityUser.LastPasswordChangeDateUtc.Value))
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.LastPasswordChangeDateUtc));
             member.LastPasswordChangeDate = identityUser.LastPasswordChangeDateUtc?.ToLocalTime() ?? DateTime.Now;
         }
 
         if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.Comments))
             && member.Comments != identityUser.Comments && identityUser.Comments.IsNullOrWhiteSpace() == false)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.Comments));
             member.Comments = identityUser.Comments;
         }
 
@@ -723,34 +741,34 @@ private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityU
             || ((member.EmailConfirmedDate.HasValue == false || member.EmailConfirmedDate.Value == default) &&
                 identityUser.EmailConfirmed))
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.EmailConfirmed));
             member.EmailConfirmedDate = identityUser.EmailConfirmed ? DateTime.Now : null;
         }
 
         if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.Name))
             && member.Name != identityUser.Name && identityUser.Name.IsNullOrWhiteSpace() == false)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.Name));
             member.Name = identityUser.Name ?? string.Empty;
         }
 
         if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.Email))
             && member.Email != identityUser.Email && identityUser.Email.IsNullOrWhiteSpace() == false)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.Email));
             member.Email = identityUser.Email!;
         }
 
         if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.AccessFailedCount))
             && member.FailedPasswordAttempts != identityUser.AccessFailedCount)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.AccessFailedCount));
             member.FailedPasswordAttempts = identityUser.AccessFailedCount;
         }
 
         if (member.IsLockedOut != identityUser.IsLockedOut)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.IsLockedOut));
             member.IsLockedOut = identityUser.IsLockedOut;
 
             if (member.IsLockedOut)
@@ -762,48 +780,48 @@ private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityU
 
         if (member.IsApproved != identityUser.IsApproved)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.IsApproved));
             member.IsApproved = identityUser.IsApproved;
         }
 
         if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.UserName))
             && member.Username != identityUser.UserName && identityUser.UserName.IsNullOrWhiteSpace() == false)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.UserName));
             member.Username = identityUser.UserName!;
         }
 
         if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.PasswordHash))
             && member.RawPasswordValue != identityUser.PasswordHash &&
             identityUser.PasswordHash.IsNullOrWhiteSpace() == false)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.PasswordHash));
             member.RawPasswordValue = identityUser.PasswordHash;
             member.PasswordConfiguration = identityUser.PasswordConfig;
         }
 
         if (member.PasswordConfiguration != identityUser.PasswordConfig)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.PasswordConfig));
             member.PasswordConfiguration = identityUser.PasswordConfig;
         }
 
         if (member.SecurityStamp != identityUser.SecurityStamp)
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.SecurityStamp));
             member.SecurityStamp = identityUser.SecurityStamp;
         }
 
         if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.Roles)))
         {
-            anythingChanged = true;
+            updatedProperties.Add(nameof(MemberIdentityUser.Roles));
             updateRoles = true;
         }
 
         // reset all changes
         identityUser.ResetDirtyProperties(false);
 
-        return anythingChanged;
+        return updatedProperties.AsReadOnly();
     }
 
     /// <inheritdoc />
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Security/MemberUserStoreTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Security/MemberUserStoreTests.cs
@@ -204,6 +204,64 @@ public async Task GivenIUpdateAUser_ThenIShouldGetASuccessResultAsync()
         _mockMemberService.Verify(x => x.ReplaceRoles(new[] { 123 }, new[] { "role1", "role2" }));
     }
 
+    [Test]
+    public async Task GivenIUpdateAUsersLoginPropertiesOnly_ThenIShouldGetASuccessResultAsync()
+    {
+        // arrange
+        var sut = CreateSut();
+        var fakeUser = new MemberIdentityUser
+        {
+            Id = "123",
+            Name = "a",
+            Email = "a@b.com",
+            UserName = "c",
+            Comments = "e",
+            LastLoginDateUtc = DateTime.UtcNow,
+            SecurityStamp = "abc",
+        };
+
+        IMemberType fakeMemberType = new MemberType(new MockShortStringHelper(), 77);
+        var mockMember = Mock.Of<IMember>(m =>
+            m.Id == 123 &&
+            m.Name == "a" &&
+            m.Email == "a@b.com" &&
+            m.Username == "c" &&
+            m.Comments == "e" &&
+            m.ContentTypeAlias == fakeMemberType.Alias &&
+            m.HasIdentity == true &&
+            m.EmailConfirmedDate == DateTime.MinValue &&
+            m.FailedPasswordAttempts == 0 &&
+            m.LastLockoutDate == DateTime.MinValue &&
+            m.IsApproved == false &&
+            m.RawPasswordValue == "xyz" &&
+            m.SecurityStamp == "xyz");
+
+        _mockMemberService.Setup(x => x.UpdateLoginPropertiesAsync(mockMember));
+        _mockMemberService.Setup(x => x.GetById(123)).Returns(mockMember);
+
+        // act
+        var identityResult = await sut.UpdateAsync(fakeUser, CancellationToken.None);
+
+        // assert
+        Assert.IsTrue(identityResult.Succeeded);
+        Assert.IsTrue(!identityResult.Errors.Any());
+
+        Assert.AreEqual(fakeUser.Name, mockMember.Name);
+        Assert.AreEqual(fakeUser.Email, mockMember.Email);
+        Assert.AreEqual(fakeUser.UserName, mockMember.Username);
+        Assert.AreEqual(fakeUser.Comments, mockMember.Comments);
+        Assert.IsFalse(fakeUser.LastPasswordChangeDateUtc.HasValue);
+        Assert.AreEqual(fakeUser.LastLoginDateUtc.Value.ToLocalTime(), mockMember.LastLoginDate);
+        Assert.AreEqual(fakeUser.AccessFailedCount, mockMember.FailedPasswordAttempts);
+        Assert.AreEqual(fakeUser.IsLockedOut, mockMember.IsLockedOut);
+        Assert.AreEqual(fakeUser.IsApproved, mockMember.IsApproved);
+        Assert.AreEqual(fakeUser.SecurityStamp, mockMember.SecurityStamp);
+
+        _mockMemberService.Verify(x => x.Save(mockMember), Times.Never);
+        _mockMemberService.Verify(x => x.UpdateLoginPropertiesAsync(mockMember));
+        _mockMemberService.Verify(x => x.GetById(123));
+    }
+
     [Test]
     public async Task GivenIDeleteUser_AndTheUserIsNotPresent_ThenIShouldGetAFailedResultAsync()
     {

Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ public override Task<IdentityResult> CreateAsync(`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`/// <inheritdoc />`
`164`		`- public override Task<IdentityResult> UpdateAsync(`
	`164`	`+ public override async Task<IdentityResult> UpdateAsync(`
`165`	`165`	`MemberIdentityUser user,`
`166`	`166`	`CancellationToken cancellationToken = default)`
`167`	`167`	`{`
`@@ -189,9 +189,21 @@ public override Task<IdentityResult> UpdateAsync(`
`189`	`189`	`var isLoginsPropertyDirty = user.IsPropertyDirty(nameof(MemberIdentityUser.Logins));`
`190`	`190`	`var isTokensPropertyDirty = user.IsPropertyDirty(nameof(MemberIdentityUser.LoginTokens));`
`191`	`191`
`192`		`- if (UpdateMemberProperties(found, user, out var updateRoles))`
	`192`	`+ IReadOnlyList<string> propertiesUpdated = UpdateMemberProperties(found, user, out var updateRoles);`
	`193`	`+`
	`194`	`+ if (propertiesUpdated.Count > 0)`
`193`	`195`	`{`
`194`		`- _memberService.Save(found);`
	`196`	`+ // As part of logging in members we update the last login date, and, if concurrent logins are disabled, the security stamp.`
	`197`	`+ // If and only if we are updating these properties, we can avoid the overhead of a full save of the member with the associated`
	`198`	`+ // locking, property updates, tag handling etc., and make a more efficient update.`
	`199`	`+ if (UpdatingOnlyLoginProperties(propertiesUpdated))`
	`200`	`+ {`
	`201`	`+ await _memberService.UpdateLoginPropertiesAsync(found);`
	`202`	`+ }`
	`203`	`+ else`
	`204`	`+ {`
	`205`	`+ _memberService.Save(found);`
	`206`	`+ }`
`195`	`207`
`196`	`208`	`if (updateRoles)`
`197`	`209`	`{`
`@@ -222,15 +234,21 @@ public override Task<IdentityResult> UpdateAsync(`
`222`	`234`	`}`
`223`	`235`
`224`	`236`	`scope.Complete();`
`225`		`- return Task.FromResult(IdentityResult.Success);`
	`237`	`+ return IdentityResult.Success;`
`226`	`238`	`}`
`227`	`239`	`catch (Exception ex)`
`228`	`240`	`{`
`229`		`- return Task.FromResult(`
`230`		`- IdentityResult.Failed(new IdentityError { Code = GenericIdentityErrorCode, Description = ex.Message }));`
	`241`	`+ return IdentityResult.Failed(new IdentityError { Code = GenericIdentityErrorCode, Description = ex.Message });`
`231`	`242`	`}`
`232`	`243`	`}`
`233`	`244`
	`245`	`+ private static bool UpdatingOnlyLoginProperties(IReadOnlyList<string> propertiesUpdated)`
	`246`	`+ {`
	`247`	`+ string[] loginPropertyUpdates = [nameof(MemberIdentityUser.LastLoginDateUtc), nameof(MemberIdentityUser.SecurityStamp)];`
	`248`	`+ return (propertiesUpdated.Count == 2 && propertiesUpdated.ContainsAll(loginPropertyUpdates)) \|\|`
	`249`	`+ (propertiesUpdated.Count == 1 && propertiesUpdated.ContainsAny(loginPropertyUpdates));`
	`250`	`+ }`
	`251`	`+`
`234`	`252`	`/// <inheritdoc />`
`235`	`253`	`public override Task<IdentityResult> DeleteAsync(`
`236`	`254`	`MemberIdentityUser user,`
`@@ -681,9 +699,9 @@ public override Task SetTokenAsync(MemberIdentityUser user, string loginProvider`
`681`	`699`	`return user;`
`682`	`700`	`}`
`683`	`701`
`684`		`- private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityUser, out bool updateRoles)`
	`702`	`+ private IReadOnlyList<string> UpdateMemberProperties(IMember member, MemberIdentityUser identityUser, out bool updateRoles)`
`685`	`703`	`{`
`686`		`- var anythingChanged = false;`
	`704`	`+ var updatedProperties = new List<string>();`
`687`	`705`	`updateRoles = false;`
`688`	`706`
`689`	`707`	`// don't assign anything if nothing has changed as this will trigger the track changes of the model`
`@@ -692,7 +710,7 @@ private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityU`
`692`	`710`	`\|\| (identityUser.LastLoginDateUtc.HasValue &&`
`693`	`711`	`member.LastLoginDate?.ToUniversalTime() != identityUser.LastLoginDateUtc.Value))`
`694`	`712`	`{`
`695`		`- anythingChanged = true;`
	`713`	`+ updatedProperties.Add(nameof(MemberIdentityUser.LastLoginDateUtc));`
`696`	`714`
`697`	`715`	`// if the LastLoginDate is being set to MinValue, don't convert it ToLocalTime`
`698`	`716`	`DateTime dt = identityUser.LastLoginDateUtc == DateTime.MinValue`
`@@ -706,14 +724,14 @@ private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityU`
`706`	`724`	`\|\| (identityUser.LastPasswordChangeDateUtc.HasValue && member.LastPasswordChangeDate?.ToUniversalTime() !=`
`707`	`725`	`identityUser.LastPasswordChangeDateUtc.Value))`
`708`	`726`	`{`
`709`		`- anythingChanged = true;`
	`727`	`+ updatedProperties.Add(nameof(MemberIdentityUser.LastPasswordChangeDateUtc));`
`710`	`728`	`member.LastPasswordChangeDate = identityUser.LastPasswordChangeDateUtc?.ToLocalTime() ?? DateTime.Now;`
`711`	`729`	`}`
`712`	`730`
`713`	`731`	`if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.Comments))`
`714`	`732`	`&& member.Comments != identityUser.Comments && identityUser.Comments.IsNullOrWhiteSpace() == false)`
`715`	`733`	`{`
`716`		`- anythingChanged = true;`
	`734`	`+ updatedProperties.Add(nameof(MemberIdentityUser.Comments));`
`717`	`735`	`member.Comments = identityUser.Comments;`
`718`	`736`	`}`
`719`	`737`
`@@ -723,34 +741,34 @@ private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityU`
`723`	`741`	`\|\| ((member.EmailConfirmedDate.HasValue == false \|\| member.EmailConfirmedDate.Value == default) &&`
`724`	`742`	`identityUser.EmailConfirmed))`
`725`	`743`	`{`
`726`		`- anythingChanged = true;`
	`744`	`+ updatedProperties.Add(nameof(MemberIdentityUser.EmailConfirmed));`
`727`	`745`	`member.EmailConfirmedDate = identityUser.EmailConfirmed ? DateTime.Now : null;`
`728`	`746`	`}`
`729`	`747`
`730`	`748`	`if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.Name))`
`731`	`749`	`&& member.Name != identityUser.Name && identityUser.Name.IsNullOrWhiteSpace() == false)`
`732`	`750`	`{`
`733`		`- anythingChanged = true;`
	`751`	`+ updatedProperties.Add(nameof(MemberIdentityUser.Name));`
`734`	`752`	`member.Name = identityUser.Name ?? string.Empty;`
`735`	`753`	`}`
`736`	`754`
`737`	`755`	`if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.Email))`
`738`	`756`	`&& member.Email != identityUser.Email && identityUser.Email.IsNullOrWhiteSpace() == false)`
`739`	`757`	`{`
`740`		`- anythingChanged = true;`
	`758`	`+ updatedProperties.Add(nameof(MemberIdentityUser.Email));`
`741`	`759`	`member.Email = identityUser.Email!;`
`742`	`760`	`}`
`743`	`761`
`744`	`762`	`if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.AccessFailedCount))`
`745`	`763`	`&& member.FailedPasswordAttempts != identityUser.AccessFailedCount)`
`746`	`764`	`{`
`747`		`- anythingChanged = true;`
	`765`	`+ updatedProperties.Add(nameof(MemberIdentityUser.AccessFailedCount));`
`748`	`766`	`member.FailedPasswordAttempts = identityUser.AccessFailedCount;`
`749`	`767`	`}`
`750`	`768`
`751`	`769`	`if (member.IsLockedOut != identityUser.IsLockedOut)`
`752`	`770`	`{`
`753`		`- anythingChanged = true;`
	`771`	`+ updatedProperties.Add(nameof(MemberIdentityUser.IsLockedOut));`
`754`	`772`	`member.IsLockedOut = identityUser.IsLockedOut;`
`755`	`773`
`756`	`774`	`if (member.IsLockedOut)`
`@@ -762,48 +780,48 @@ private bool UpdateMemberProperties(IMember member, MemberIdentityUser identityU`
`762`	`780`
`763`	`781`	`if (member.IsApproved != identityUser.IsApproved)`
`764`	`782`	`{`
`765`		`- anythingChanged = true;`
	`783`	`+ updatedProperties.Add(nameof(MemberIdentityUser.IsApproved));`
`766`	`784`	`member.IsApproved = identityUser.IsApproved;`
`767`	`785`	`}`
`768`	`786`
`769`	`787`	`if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.UserName))`
`770`	`788`	`&& member.Username != identityUser.UserName && identityUser.UserName.IsNullOrWhiteSpace() == false)`
`771`	`789`	`{`
`772`		`- anythingChanged = true;`
	`790`	`+ updatedProperties.Add(nameof(MemberIdentityUser.UserName));`
`773`	`791`	`member.Username = identityUser.UserName!;`
`774`	`792`	`}`
`775`	`793`
`776`	`794`	`if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.PasswordHash))`
`777`	`795`	`&& member.RawPasswordValue != identityUser.PasswordHash &&`
`778`	`796`	`identityUser.PasswordHash.IsNullOrWhiteSpace() == false)`
`779`	`797`	`{`
`780`		`- anythingChanged = true;`
	`798`	`+ updatedProperties.Add(nameof(MemberIdentityUser.PasswordHash));`
`781`	`799`	`member.RawPasswordValue = identityUser.PasswordHash;`
`782`	`800`	`member.PasswordConfiguration = identityUser.PasswordConfig;`
`783`	`801`	`}`
`784`	`802`
`785`	`803`	`if (member.PasswordConfiguration != identityUser.PasswordConfig)`
`786`	`804`	`{`
`787`		`- anythingChanged = true;`
	`805`	`+ updatedProperties.Add(nameof(MemberIdentityUser.PasswordConfig));`
`788`	`806`	`member.PasswordConfiguration = identityUser.PasswordConfig;`
`789`	`807`	`}`
`790`	`808`
`791`	`809`	`if (member.SecurityStamp != identityUser.SecurityStamp)`
`792`	`810`	`{`
`793`		`- anythingChanged = true;`
	`811`	`+ updatedProperties.Add(nameof(MemberIdentityUser.SecurityStamp));`
`794`	`812`	`member.SecurityStamp = identityUser.SecurityStamp;`
`795`	`813`	`}`
`796`	`814`
`797`	`815`	`if (identityUser.IsPropertyDirty(nameof(MemberIdentityUser.Roles)))`
`798`	`816`	`{`
`799`		`- anythingChanged = true;`
	`817`	`+ updatedProperties.Add(nameof(MemberIdentityUser.Roles));`
`800`	`818`	`updateRoles = true;`
`801`	`819`	`}`
`802`	`820`
`803`	`821`	`// reset all changes`
`804`	`822`	`identityUser.ResetDirtyProperties(false);`
`805`	`823`
`806`		`- return anythingChanged;`
	`824`	`+ return updatedProperties.AsReadOnly();`
`807`	`825`	`}`
`808`	`826`
`809`	`827`	`/// <inheritdoc />`