Utilizing a cache for user data

src/GitHub.Api/Application/ApplicationManagerBase.cs

@@ -78,6 +78,7 @@ private async Task SetupGit()
                 }
             }
 
+            Environment.User.Initialize(GitClient);
         }
 
         public ITask InitializeRepository()

src/GitHub.Api/Cache/CacheInterfaces.cs

@@ -49,7 +49,8 @@ public interface IGitLocksCache : IManagedCache
 
     public interface IGitUserCache : IManagedCache
     {
-        User User { get; }
+        string Name { get; set; }
+        string Email { get; set; }
     }
 
     public interface IGitStatusCache : IManagedCache

src/GitHub.Api/Git/GitClient.cs

@@ -23,7 +23,7 @@ ITask<string> GetConfig(string key, GitConfigSource configSource,
         ITask<string> SetConfig(string key, string value, GitConfigSource configSource,
             IOutputProcessor<string> processor = null);
 
-        ITask<User> GetConfigUserAndEmail();
+        ITask<GitUser> GetConfigUserAndEmail();
 
         ITask<List<GitLock>> ListLocks(bool local,
             BaseOutputListProcessor<GitLock> processor = null);
@@ -84,7 +84,7 @@ ITask<string> Unlock(string file, bool force,
 
         ITask<Version> LfsVersion(IOutputProcessor<Version> processor = null);
 
-        ITask<User> SetConfigUserAndEmail(string username, string email);
+        ITask<GitUser> SetConfigNameAndEmail(string username, string email);
     }
 
     class GitClient : IGitClient
@@ -259,7 +259,7 @@ public ITask<string> SetConfig(string key, string value, GitConfigSource configS
                 .Configure(processManager);
         }
 
-        public ITask<User> GetConfigUserAndEmail()
+        public ITask<GitUser> GetConfigUserAndEmail()
         {
             string username = null;
             string email = null;
@@ -279,15 +279,15 @@ public ITask<User> GetConfigUserAndEmail()
                     }
                 })).Then(success => {
                 Logger.Trace("{0}:{1} {2}:{3}", UserNameConfigKey, username, UserEmailConfigKey, email);
-                return new User { Name = username, Email = email };
+                return new GitUser(username, email);
             });
         }
 
-        public ITask<User> SetConfigUserAndEmail(string username, string email)
+        public ITask<GitUser> SetConfigNameAndEmail(string username, string email)
         {
             return SetConfig(UserNameConfigKey, username, GitConfigSource.User)
                 .Then(SetConfig(UserEmailConfigKey, email, GitConfigSource.User))
-                .Then(b => new User { Name = username, Email = email });
+                .Then(b => new GitUser(username, email));
         }
 
         public ITask<List<GitLock>> ListLocks(bool local, BaseOutputListProcessor<GitLock> processor = null)
@@ -464,4 +464,26 @@ public ITask<string> Unlock(string file, bool force,
 
         protected static ILogging Logger { get; } = Logging.GetLogger<GitClient>();
     }
+
+    public struct GitUser
+    {
+        public static GitUser Default = new GitUser();
+
+        public string name;
+        public string email;
+
+        public string Name { get { return name; } }
+        public string Email { get { return email; } }
+
+        public GitUser(string name, string email)
+        {
+            this.name = name;
+            this.email = email;
+        }
+
+        public override string ToString()
+        {
+            return $"Name:\"{Name}\" Email:\"{Email}\"";
+        }
+    }
 }

src/GitHub.Api/Git/IRepository.cs

@@ -64,7 +64,6 @@ public interface IRepository : IEquatable<IRepository>
         GitRemote[] Remotes { get; }
         GitBranch[] LocalBranches { get; }
         GitBranch[] RemoteBranches { get; }
-        IUser User { get; set; }
         List<GitLock> CurrentLocks { get; }
         string CurrentBranchName { get; }
         List<GitLogEntry> CurrentLog { get; }

src/GitHub.Api/Git/ManagedCacheExtensions.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace GitHub.Unity
+{
+    static class ManagedCacheExtensions
+    {
+        public static bool IsLastUpdatedTimeDifferent(this IManagedCache managedCache, CacheUpdateEvent cacheUpdateEvent)
+        {
+            bool isDifferent;
+            if (cacheUpdateEvent.UpdatedTimeString == null)
+            {
+                isDifferent = managedCache.LastUpdatedAt != DateTimeOffset.MinValue;
+            }
+            else
+            {
+                isDifferent = managedCache.LastUpdatedAt.ToString() != cacheUpdateEvent.UpdatedTimeString;
+            }
+            return isDifferent;
+        }
+    }
+}

src/GitHub.Api/Git/Repository.cs

@@ -35,7 +35,6 @@ public Repository(NPath localPath, ICacheContainer container)
             Guard.ArgumentNotNull(localPath, nameof(localPath));
 
             LocalPath = localPath;
-            User = new User();
 
             cacheContainer = container;
             cacheContainer.CacheInvalidated += CacheContainer_OnCacheInvalidated;
@@ -57,7 +56,6 @@ public void Initialize(IRepositoryManager initRepositoryManager)
             repositoryManager.OnLocalBranchRemoved += RepositoryManager_OnLocalBranchRemoved;
             repositoryManager.OnRemoteBranchAdded += RepositoryManager_OnRemoteBranchAdded;
             repositoryManager.OnRemoteBranchRemoved += RepositoryManager_OnRemoteBranchRemoved;
-            repositoryManager.OnGitUserLoaded += user => User = user;
 
             UpdateGitStatus();
             UpdateGitLog();
@@ -150,7 +148,7 @@ public void UpdateConfigData()
         public void CheckLogChangedEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.GitLogCache;
-            var raiseEvent = ShouldRaiseCacheEvent(cacheUpdateEvent, managedCache);
+            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
 
             Logger.Trace("Check GitLogCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
@@ -166,7 +164,7 @@ public void CheckLogChangedEvent(CacheUpdateEvent cacheUpdateEvent)
         public void CheckStatusChangedEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.GitStatusCache;
-            var raiseEvent = ShouldRaiseCacheEvent(cacheUpdateEvent, managedCache);
+            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
 
             Logger.Trace("Check GitStatusCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
@@ -197,7 +195,7 @@ public void CheckCurrentBranchAndRemoteChangedEvent(CacheUpdateEvent cacheUpdate
         private void CheckRepositoryInfoCacheEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.RepositoryInfoCache;
-            var raiseEvent = ShouldRaiseCacheEvent(cacheUpdateEvent, managedCache);
+            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
 
             Logger.Trace("Check RepositoryInfoCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
@@ -214,7 +212,7 @@ public void CheckLocksChangedEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             CacheUpdateEvent cacheUpdateEvent1 = cacheUpdateEvent;
             var managedCache = cacheContainer.GitLocksCache;
-            var raiseEvent = ShouldRaiseCacheEvent(cacheUpdateEvent1, managedCache);
+            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent1);
 
             Logger.Trace("Check GitLocksCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent1.UpdatedTimeString ?? "[NULL]", raiseEvent);
@@ -277,7 +275,7 @@ public bool Equals(IRepository other)
         private void CheckBranchCacheEvent(CacheUpdateEvent cacheUpdateEvent)
         {
             var managedCache = cacheContainer.BranchCache;
-            var raiseEvent = ShouldRaiseCacheEvent(cacheUpdateEvent, managedCache);
+            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
 
             Logger.Trace("Check BranchCache CacheUpdateEvent Current:{0} Check:{1} Result:{2}", managedCache.LastUpdatedAt,
                 cacheUpdateEvent.UpdatedTimeString ?? "[NULL]", raiseEvent);
@@ -290,20 +288,6 @@ private void CheckBranchCacheEvent(CacheUpdateEvent cacheUpdateEvent)
             }
         }
 
-        private static bool ShouldRaiseCacheEvent(CacheUpdateEvent cacheUpdateEvent, IManagedCache managedCache)
-        {
-            bool raiseEvent;
-            if (cacheUpdateEvent.UpdatedTimeString == null)
-            {
-                raiseEvent = managedCache.LastUpdatedAt != DateTimeOffset.MinValue;
-            }
-            else
-            {
-                raiseEvent = managedCache.LastUpdatedAt.ToString() != cacheUpdateEvent.UpdatedTimeString;
-            }
-            return raiseEvent;
-        }
-
         private void CacheContainer_OnCacheInvalidated(CacheType cacheType)
         {
             switch (cacheType)
@@ -669,27 +653,129 @@ public bool IsGitHub
             "{0} Owner: {1} Name: {2} CloneUrl: {3} LocalPath: {4} Branch: {5} Remote: {6}", GetHashCode(), Owner, Name,
             CloneUrl, LocalPath, CurrentBranch, CurrentRemote);
 
-        public IUser User { get; set; }
-
         protected static ILogging Logger { get; } = Logging.GetLogger<Repository>();
     }
 
     public interface IUser
     {
-        string Name { get; set; }
-        string Email { get; set; }
+        string Name { get; }
+        string Email { get; }
+        event Action<CacheUpdateEvent> Changed;
+        void CheckUserChangedEvent(CacheUpdateEvent cacheUpdateEvent);
+        void Initialize(IGitClient client);
+        void SetNameAndEmail(string name, string email);
     }
 
     [Serializable]
     public class User : IUser
     {
+        private ICacheContainer cacheContainer;
+        private IGitClient gitClient;
+
+        public event Action<CacheUpdateEvent> Changed;
+
+        public User(ICacheContainer cacheContainer)
+        {
+            this.cacheContainer = cacheContainer;
+
+            cacheContainer.GitUserCache.CacheInvalidated += GitUserCacheOnCacheInvalidated;
+            cacheContainer.GitUserCache.CacheUpdated += GitUserCacheOnCacheUpdated;
+        }
+
+        public void CheckUserChangedEvent(CacheUpdateEvent cacheUpdateEvent)
+        {
+            var managedCache = cacheContainer.GitUserCache;
+            var raiseEvent = managedCache.IsLastUpdatedTimeDifferent(cacheUpdateEvent);
+
+            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() };
+                HandleUserCacheUpdatedEvent(updateEvent);
+            }
+        }
+
+        public void Initialize(IGitClient client)
+        {
+            Guard.ArgumentNotNull(client, nameof(client));
+
+            Logger.Trace("Initialize");
+
+            gitClient = client;
+            UpdateUserAndEmail();
+        }
+
+        public void SetNameAndEmail(string name, string email)
+        {
+            gitClient.SetConfigNameAndEmail(name, email)
+                     .ThenInUI((success, value) => {
+                         if (success)
+                         {
+                             Name = value.Name;
+                             Email = value.Email;
+                         }
+                     }).Start();
+        }
+
         public override string ToString()
         {
             return String.Format("Name: {0} Email: {1}", Name, Email);
         }
 
-        public string Name { get; set; }
-        public string Email { get; set; }
+        public string Name
+        {
+            get { return cacheContainer.GitUserCache.Name; }
+            private set { cacheContainer.GitUserCache.Name = value; }
+        }
+
+        public string Email
+        {
+            get { return cacheContainer.GitUserCache.Email; }
+            private set { cacheContainer.GitUserCache.Email = value; }
+        }
+
+        private void GitUserCacheOnCacheUpdated(DateTimeOffset timeOffset)
+        {
+            HandleUserCacheUpdatedEvent(new CacheUpdateEvent
+            {
+                UpdatedTimeString = timeOffset.ToString()
+            });
+        }
+
+        private void GitUserCacheOnCacheInvalidated()
+        {
+            Logger.Trace("GitUserCache Invalidated");
+            UpdateUserAndEmail();
+        }
+
+        private void HandleUserCacheUpdatedEvent(CacheUpdateEvent cacheUpdateEvent)
+        {
+            Logger.Trace("GitUserCache Updated {0}", cacheUpdateEvent.UpdatedTimeString);
+            Changed?.Invoke(cacheUpdateEvent);
+        }
+
+        private void UpdateUserAndEmail()
+        {
+            if (gitClient != null)
+            {
+                Logger.Trace("UpdateUserAndEmail");
+
+                gitClient.GetConfigUserAndEmail()
+                    .ThenInUI((success, value) =>
+                    {
+                        if (success)
+                        {
+                            Name = value.Name;
+                            Email = value.Email;
+                        }
+                    }).Start();
+            }
+        }
+
+        protected static ILogging Logger { get; } = Logging.GetLogger<User>();
     }
 
     [Serializable]

src/GitHub.Api/Git/RepositoryManager.cs

@@ -8,7 +8,6 @@ namespace GitHub.Unity
     public interface IRepositoryManager : IDisposable
     {
         event Action<ConfigBranch?, ConfigRemote?> OnCurrentBranchAndRemoteUpdated;
-        event Action<IUser> OnGitUserLoaded;
         event Action<bool> OnIsBusyChanged;
         event Action<string> OnLocalBranchAdded;
         event Action<Dictionary<string, ConfigBranch>> OnLocalBranchListUpdated;
@@ -101,7 +100,6 @@ class RepositoryManager : IRepositoryManager
         private bool isBusy;
 
         public event Action<ConfigBranch?, ConfigRemote?> OnCurrentBranchAndRemoteUpdated;
-        public event Action<IUser> OnGitUserLoaded;
         public event Action<bool> OnIsBusyChanged;
         public event Action<string> OnLocalBranchAdded;
         public event Action<Dictionary<string, ConfigBranch>> OnLocalBranchListUpdated;
@@ -149,7 +147,6 @@ public void Start()
             Logger.Trace("Start");
 
             UpdateConfigData();
-            LoadGitUser();
             watcher.Start();
         }
 
@@ -300,15 +297,6 @@ public void UpdateConfigData()
             UpdateConfigData(false);
         }
 
-        private void LoadGitUser()
-        {
-            GitClient.GetConfigUserAndEmail()
-                .Then((success, user) => {
-                    Logger.Trace("OnGitUserLoaded: {0}", user);
-                    OnGitUserLoaded?.Invoke(user);
-                }).Start();
-        }
-
         private void SetupWatcher()
         {
             watcher.HeadChanged += Watcher_OnHeadChanged;

src/GitHub.Api/GitHub.Api.csproj

@@ -103,6 +103,7 @@
     <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" />