Merge pull request #498 from github-for-unity/fixes/cache-update-event

StanleyGoldman · web-flow · commit 1a30da45d40c · 2017-12-04T12:12:12.000-05:00
Handling the UpdatedTime in CacheUpdateEvent better
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
@@ -113,31 +113,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);
             }
         }
@@ -160,32 +160,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);
             }
         }
@@ -240,15 +239,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);
             }
         }
@@ -285,7 +284,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:
@@ -627,15 +626,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);
             }
         }
@@ -683,7 +682,7 @@ private void GitUserCacheOnCacheUpdated(DateTimeOffset timeOffset)
         {
             HandleUserCacheUpdatedEvent(new CacheUpdateEvent
             {
-                UpdatedTimeString = timeOffset.ToString()
+                UpdatedTime = timeOffset
             });
         }
 
@@ -726,6 +725,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\GitAheadBehindStatus.cs" />
     <Compile Include="Git\Tasks\GitAheadBehindStatusTask.cs" />
     <Compile Include="Git\Tasks\GitLfsVersionTask.cs" />

Original file line number	Diff line number	Diff line change
`@@ -113,31 +113,31 @@ public ITask ReleaseLock(string file, bool force)`
`113`	`113`	`public void CheckLogChangedEvent(CacheUpdateEvent cacheUpdateEvent)`
`114`	`114`	`{`
`115`	`115`	`var managedCache = cacheContainer.GitLogCache;`
`116`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`116`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`117`	`117`
`118`	`118`	`Logger.Trace("Check GitLogCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`119`	`119`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`120`	`120`
`121`	`121`	`if (raiseEvent)`
`122`	`122`	`{`
`123`	`123`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`124`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`124`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`125`	`125`	`HandleGitLogCacheUpdatedEvent(updateEvent);`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
`129`	`129`	`public void CheckStatusChangedEvent(CacheUpdateEvent cacheUpdateEvent)`
`130`	`130`	`{`
`131`	`131`	`var managedCache = cacheContainer.GitStatusCache;`
`132`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`132`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`133`	`133`
`134`	`134`	`Logger.Trace("Check GitStatusCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`135`	`135`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`136`	`136`
`137`	`137`	`if (raiseEvent)`
`138`	`138`	`{`
`139`	`139`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`140`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`140`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`141`	`141`	`HandleGitStatusCacheUpdatedEvent(updateEvent);`
`142`	`142`	`}`
`143`	`143`	`}`
`@@ -160,32 +160,31 @@ public void CheckCurrentBranchAndRemoteChangedEvent(CacheUpdateEvent cacheUpdate`
`160`	`160`	`private void CheckRepositoryInfoCacheEvent(CacheUpdateEvent cacheUpdateEvent)`
`161`	`161`	`{`
`162`	`162`	`var managedCache = cacheContainer.RepositoryInfoCache;`
`163`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`163`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`164`	`164`
`165`	`165`	`Logger.Trace("Check RepositoryInfoCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`166`	`166`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`167`	`167`
`168`	`168`	`if (raiseEvent)`
`169`	`169`	`{`
`170`	`170`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`171`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`171`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset};`
`172`	`172`	`HandleRepositoryInfoCacheUpdatedEvent(updateEvent);`
`173`	`173`	`}`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`public void CheckLocksChangedEvent(CacheUpdateEvent cacheUpdateEvent)`
`177`	`177`	`{`
`178`		`- CacheUpdateEvent cacheUpdateEvent1 = cacheUpdateEvent;`
`179`	`178`	`var managedCache = cacheContainer.GitLocksCache;`
`180`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent1);`
	`179`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`181`	`180`
`182`	`181`	`Logger.Trace("Check GitLocksCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`183`		`- cacheUpdateEvent1.UpdatedTimeString ?? "[NULL]", raiseEvent);`
	`182`	`+ cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`184`	`183`
`185`	`184`	`if (raiseEvent)`
`186`	`185`	`{`
`187`	`186`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`188`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`187`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`189`	`188`	`HandleGitLocksCacheUpdatedEvent(updateEvent);`
`190`	`189`	`}`
`191`	`190`	`}`
`@@ -240,15 +239,15 @@ public bool Equals(IRepository other)`
`240`	`239`	`private void CheckBranchCacheEvent(CacheUpdateEvent cacheUpdateEvent)`
`241`	`240`	`{`
`242`	`241`	`var managedCache = cacheContainer.BranchCache;`
`243`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`242`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`244`	`243`
`245`	`244`	`Logger.Trace("Check BranchCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`246`	`245`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`247`	`246`
`248`	`247`	`if (raiseEvent)`
`249`	`248`	`{`
`250`	`249`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`251`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`250`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`252`	`251`	`HandleBranchCacheUpdatedEvent(updateEvent);`
`253`	`252`	`}`
`254`	`253`	`}`
`@@ -285,7 +284,7 @@ private void CacheContainer_OnCacheInvalidated(CacheType cacheType)`
`285`	`284`
`286`	`285`	`private void CacheContainer_OnCacheUpdated(CacheType cacheType, DateTimeOffset offset)`
`287`	`286`	`{`
`288`		`- var cacheUpdateEvent = new CacheUpdateEvent { UpdatedTimeString = offset.ToString() };`
	`287`	`+ var cacheUpdateEvent = new CacheUpdateEvent { UpdatedTime = offset };`
`289`	`288`	`switch (cacheType)`
`290`	`289`	`{`
`291`	`290`	`case CacheType.BranchCache:`
`@@ -627,15 +626,15 @@ public User(ICacheContainer cacheContainer)`
`627`	`626`	`public void CheckUserChangedEvent(CacheUpdateEvent cacheUpdateEvent)`
`628`	`627`	`{`
`629`	`628`	`var managedCache = cacheContainer.GitUserCache;`
`630`		`- var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);`
	`629`	`+ var raiseEvent = managedCache.LastUpdatedAt != cacheUpdateEvent.UpdatedTime;`
`631`	`630`
`632`	`631`	`Logger.Trace("Check GitUserCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,`
`633`	`632`	`cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);`
`634`	`633`
`635`	`634`	`if (raiseEvent)`
`636`	`635`	`{`
`637`	`636`	`var dateTimeOffset = managedCache.LastUpdatedAt;`
`638`		`- var updateEvent = new CacheUpdateEvent { UpdatedTimeString = dateTimeOffset.ToString() };`
	`637`	`+ var updateEvent = new CacheUpdateEvent { UpdatedTime = dateTimeOffset };`
`639`	`638`	`HandleUserCacheUpdatedEvent(updateEvent);`
`640`	`639`	`}`
`641`	`640`	`}`
`@@ -683,7 +682,7 @@ private void GitUserCacheOnCacheUpdated(DateTimeOffset timeOffset)`
`683`	`682`	`{`
`684`	`683`	`HandleUserCacheUpdatedEvent(new CacheUpdateEvent`
`685`	`684`	`{`
`686`		`- UpdatedTimeString = timeOffset.ToString()`
	`685`	`+ UpdatedTime = timeOffset`
`687`	`686`	`});`
`688`	`687`	`}`
`689`	`688`
`@@ -726,6 +725,31 @@ private void UpdateUserAndEmail()`
`726`	`725`	`[Serializable]`
`727`	`726`	`public struct CacheUpdateEvent`
`728`	`727`	`{`
`729`		`- public string UpdatedTimeString;`
	`728`	`+ [NonSerialized] private DateTimeOffset? updatedTimeValue;`
	`729`	`+ private string updatedTimeString;`
	`730`	`+`
	`731`	`+ public DateTimeOffset UpdatedTime`
	`732`	`+ {`
	`733`	`+ get`
	`734`	`+ {`
	`735`	`+ if (!updatedTimeValue.HasValue)`
	`736`	`+ {`
	`737`	`+ UpdatedTime = DateTimeOffset.MinValue;`
	`738`	`+ }`
	`739`	`+`
	`740`	`+ return updatedTimeValue.Value;`
	`741`	`+ }`
	`742`	`+ set`
	`743`	`+ {`
	`744`	`+ updatedTimeValue = value;`
	`745`	`+ UpdatedTimeString = value.ToString(Constants.Iso8601Format);`
	`746`	`+ }`
	`747`	`+ }`
	`748`	`+`
	`749`	`+ public string UpdatedTimeString`
	`750`	`+ {`
	`751`	`+ get { return updatedTimeString; }`
	`752`	`+ private set { updatedTimeString = value; }`
	`753`	`+ }`
`730`	`754`	`}`
`731`	`755`	`}`