Handling the UpdatedTime in CacheUpdateEvent better

StanleyGoldman · StanleyGoldman · commit 4ac0f0421e3c · 2017-12-04T10:00:35.000-05:00
UpdatedTime was not being serialized in the proper format and this was
causing needles updates to views from cache
diff --git a/src/GitHub.Api/Git/ManagedCacheExtensions.cs b/src/GitHub.Api/Git/ManagedCacheExtensions.cs
diff --git a/src/GitHub.Api/Git/Repository.cs b/src/GitHub.Api/Git/Repository.cs
@@ -111,31 +111,31 @@ public ITask ReleaseLock(string file, bool force)
         public void CheckLogChangedEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.GitLogCache;
-            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
+            var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;
 
             Logger.Trace("Check GitLogCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
 
             if (raiseEvent)
             {
                 var dateTimeOffset = managedCache.LastUpdatedAt;
-                var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };
+                var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };
                 HandleGitLogCacheUpdatedEvent(updateEvent);
             }
         }
 
         public void CheckStatusChangedEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.GitStatusCache;
-            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
+            var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;
 
             Logger.Trace("Check GitStatusCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
 
             if (raiseEvent)
             {
                 var dateTimeOffset = managedCache.LastUpdatedAt;
-                var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };
+                var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };
                 HandleGitStatusCacheUpdatedEvent(updateEvent);
             }
         }
@@ -158,32 +158,31 @@ public void CheckCurrentBranchAndRemoteChangedEvent(CacheUpdateEvent cacheUpdate
         private void CheckRepositoryInfoCacheEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.RepositoryInfoCache;
-            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
+            var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;
 
             Logger.Trace("Check RepositoryInfoCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
 
             if (raiseEvent)
             {
                 var dateTimeOffset = managedCache.LastUpdatedAt;
-                var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };
+                var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset};
                 HandleRepositoryInfoCacheUpdatedEvent(updateEvent);
             }
         }
 
         public void CheckLocksChangedEvent(CacheUpdateEvent cacheUpdateEvent)
         {
-            CacheUpdateEvent cacheUpdateEvent1 = cacheUpdateEvent;
             var managedCache = cacheContainer.GitLocksCache;
-            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent1);
+            var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;
 
             Logger.Trace("Check GitLocksCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
-                cacheUpdateEvent1.UpdatedTimeString ?? "[NULL]", raiseEvent);
+                cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
 
             if (raiseEvent)
             {
                 var dateTimeOffset = managedCache.LastUpdatedAt;
-                var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };
+                var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };
                 HandleGitLocksCacheUpdatedEvent(updateEvent);
             }
         }
@@ -238,15 +237,15 @@ public bool Equals(IRepository other)
         private void CheckBranchCacheEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.BranchCache;
-            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
+            var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;
 
             Logger.Trace("Check BranchCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
 
             if (raiseEvent)
             {
                 var dateTimeOffset = managedCache.LastUpdatedAt;
-                var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };
+                var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };
                 HandleBranchCacheUpdatedEvent(updateEvent);
             }
         }
@@ -283,7 +282,7 @@ private void CacheContainer_OnCacheInvalidated(CacheType cacheType)
 
         private void CacheContainer_OnCacheUpdated(CacheType cacheType, DateTimeOffset offset)
         {
-            var cacheUpdateEvent = new CacheUpdateEvent { UpdatedTimeString = offset.ToString() };
+            var cacheUpdateEvent = new CacheUpdateEvent { UpdatedTime = offset };
             switch (cacheType)
             {
                 case CacheType.BranchCache:
@@ -587,15 +586,15 @@ public User(ICacheContainer cacheContainer)
         public void CheckUserChangedEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.GitUserCache;
-            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
+            var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;
 
             Logger.Trace("Check GitUserCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
 
             if (raiseEvent)
             {
                 var dateTimeOffset = managedCache.LastUpdatedAt;
-                var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };
+                var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };
                 HandleUserCacheUpdatedEvent(updateEvent);
             }
         }
@@ -642,7 +641,7 @@ private void GitUserCacheOnCacheUpdated(DateTimeOffset timeOffset)
         {
             HandleUserCacheUpdatedEvent(new CacheUpdateEvent
             {
-                UpdatedTimeString = timeOffset.ToString()
+                UpdatedTime = timeOffset
             });
         }
 
@@ -682,6 +681,31 @@ private void UpdateUserAndEmail()
     [Serializable]
     public struct CacheUpdateEvent
     {
-        public string UpdatedTimeString;
+        [NonSerialized] private DateTimeOffset? updatedTimeValue;
+        private string updatedTimeString;
+
+        public DateTimeOffset UpdatedTime
+        {
+            get
+            {
+                if (!updatedTimeValue.HasValue)
+                {
+                    UpdatedTime = DateTimeOffset.MinValue;
+                }
+
+                return updatedTimeValue.Value;
+            }
+            set
+            {
+                updatedTimeValue = value;
+                UpdatedTimeString = value.ToString(Constants.Iso8601Format);
+            }
+        }
+
+        public string UpdatedTimeString
+        {
+            get { return updatedTimeString; }
+            private set { updatedTimeString = value; }
+        }
     }
 }
diff --git a/src/GitHub.Api/GitHub.Api.csproj b/src/GitHub.Api/GitHub.Api.csproj
@@ -103,7 +103,6 @@
     <Compile Include="Application\Organization.cs" />
     <Compile Include="Cache\CacheInterfaces.cs" />
     <Compile Include="Extensions\ListExtensions.cs" />
-    <Compile Include="Git\ManagedCacheExtensions.cs" />
     <Compile Include="Git\Tasks\GitLfsVersionTask.cs" />
     <Compile Include="Git\Tasks\GitVersionTask.cs" />
     <Compile Include="Git\ValidateGitInstallResult.cs" />

Original file line number	Diff line number	Diff line change
`@@ -111,31 +111,31 @@ public ITask ReleaseLock(string file, bool force)`
`111`	`111`	`public void CheckLogChangedEvent(CacheUpdateEvent cacheUpdateEvent)`
`112`	`112`	`{`
`113`	`113`	`var managedCache = cacheContainer.GitLogCache;`
`114`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`114`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`115`	`115`
`116`	`116`	`Logger.Trace("Check GitLogCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`117`	`117`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`118`	`118`
`119`	`119`	`if (raiseEvent)`
`120`	`120`	`{`
`121`	`121`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`122`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`122`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`123`	`123`	`HandleGitLogCacheUpdatedEvent(updateEvent);`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`public void CheckStatusChangedEvent(CacheUpdateEvent cacheUpdateEvent)`
`128`	`128`	`{`
`129`	`129`	`var managedCache = cacheContainer.GitStatusCache;`
`130`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`130`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`131`	`131`
`132`	`132`	`Logger.Trace("Check GitStatusCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`133`	`133`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`134`	`134`
`135`	`135`	`if (raiseEvent)`
`136`	`136`	`{`
`137`	`137`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`138`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`138`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`139`	`139`	`HandleGitStatusCacheUpdatedEvent(updateEvent);`
`140`	`140`	`}`
`141`	`141`	`}`
`@@ -158,32 +158,31 @@ public void CheckCurrentBranchAndRemoteChangedEvent(CacheUpdateEvent cacheUpdate`
`158`	`158`	`private void CheckRepositoryInfoCacheEvent(CacheUpdateEvent cacheUpdateEvent)`
`159`	`159`	`{`
`160`	`160`	`var managedCache = cacheContainer.RepositoryInfoCache;`
`161`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`161`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`162`	`162`
`163`	`163`	`Logger.Trace("Check RepositoryInfoCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`164`	`164`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`165`	`165`
`166`	`166`	`if (raiseEvent)`
`167`	`167`	`{`
`168`	`168`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`169`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`169`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset};`
`170`	`170`	`HandleRepositoryInfoCacheUpdatedEvent(updateEvent);`
`171`	`171`	`}`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`public void CheckLocksChangedEvent(CacheUpdateEvent cacheUpdateEvent)`
`175`	`175`	`{`
`176`		`- CacheUpdateEvent cacheUpdateEvent1 = cacheUpdateEvent;`
`177`	`176`	`var managedCache = cacheContainer.GitLocksCache;`
`178`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent1);`
	`177`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`179`	`178`
`180`	`179`	`Logger.Trace("Check GitLocksCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`181`		`- cacheUpdateEvent1.UpdatedTimeString ?? "[NULL]", raiseEvent);`
	`180`	`+ cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`182`	`181`
`183`	`182`	`if (raiseEvent)`
`184`	`183`	`{`
`185`	`184`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`186`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`185`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`187`	`186`	`HandleGitLocksCacheUpdatedEvent(updateEvent);`
`188`	`187`	`}`
`189`	`188`	`}`
`@@ -238,15 +237,15 @@ public bool Equals(IRepository other)`
`238`	`237`	`private void CheckBranchCacheEvent(CacheUpdateEvent cacheUpdateEvent)`
`239`	`238`	`{`
`240`	`239`	`var managedCache = cacheContainer.BranchCache;`
`241`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`240`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`242`	`241`
`243`	`242`	`Logger.Trace("Check BranchCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`244`	`243`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`245`	`244`
`246`	`245`	`if (raiseEvent)`
`247`	`246`	`{`
`248`	`247`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`249`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`248`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`250`	`249`	`HandleBranchCacheUpdatedEvent(updateEvent);`
`251`	`250`	`}`
`252`	`251`	`}`
`@@ -283,7 +282,7 @@ private void CacheContainer_OnCacheInvalidated(CacheType cacheType)`
`283`	`282`
`284`	`283`	`private void CacheContainer_OnCacheUpdated(CacheType cacheType, DateTimeOffset offset)`
`285`	`284`	`{`
`286`		`- var cacheUpdateEvent = new CacheUpdateEvent { UpdatedTimeString = offset.ToString() };`
	`285`	`+ var cacheUpdateEvent = new CacheUpdateEvent { UpdatedTime = offset };`
`287`	`286`	`switch (cacheType)`
`288`	`287`	`{`
`289`	`288`	`case CacheType.BranchCache:`
`@@ -587,15 +586,15 @@ public User(ICacheContainer cacheContainer)`
`587`	`586`	`public void CheckUserChangedEvent(CacheUpdateEvent cacheUpdateEvent)`
`588`	`587`	`{`
`589`	`588`	`var managedCache = cacheContainer.GitUserCache;`
`590`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`589`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`591`	`590`
`592`	`591`	`Logger.Trace("Check GitUserCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`593`	`592`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`594`	`593`
`595`	`594`	`if (raiseEvent)`
`596`	`595`	`{`
`597`	`596`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`598`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`597`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`599`	`598`	`HandleUserCacheUpdatedEvent(updateEvent);`
`600`	`599`	`}`
`601`	`600`	`}`
`@@ -642,7 +641,7 @@ private void GitUserCacheOnCacheUpdated(DateTimeOffset timeOffset)`
`642`	`641`	`{`
`643`	`642`	`HandleUserCacheUpdatedEvent(new CacheUpdateEvent`
`644`	`643`	`{`
`645`		`- UpdatedTimeString = timeOffset.ToString()`
	`644`	`+ UpdatedTime = timeOffset`
`646`	`645`	`});`
`647`	`646`	`}`
`648`	`647`
`@@ -682,6 +681,31 @@ private void UpdateUserAndEmail()`
`682`	`681`	`[Serializable]`
`683`	`682`	`public struct CacheUpdateEvent`
`684`	`683`	`{`
`685`		`- public string UpdatedTimeString;`
	`684`	`+ [NonSerialized] private DateTimeOffset? updatedTimeValue;`
	`685`	`+ private string updatedTimeString;`
	`686`	`+`
	`687`	`+ public DateTimeOffset UpdatedTime`
	`688`	`+ {`
	`689`	`+ get`
	`690`	`+ {`
	`691`	`+ if (!updatedTimeValue.HasValue)`
	`692`	`+ {`
	`693`	`+ UpdatedTime = DateTimeOffset.MinValue;`
	`694`	`+ }`
	`695`	`+`
	`696`	`+ return updatedTimeValue.Value;`
	`697`	`+ }`
	`698`	`+ set`
	`699`	`+ {`
	`700`	`+ updatedTimeValue = value;`
	`701`	`+ UpdatedTimeString = value.ToString(Constants.Iso8601Format);`
	`702`	`+ }`
	`703`	`+ }`
	`704`	`+`
	`705`	`+ public string UpdatedTimeString`
	`706`	`+ {`
	`707`	`+ get { return updatedTimeString; }`
	`708`	`+ private set { updatedTimeString = value; }`
	`709`	`+ }`
`686`	`710`	`}`
`687`	`711`	`}`