Adding a CacheManager

src/GitHub.Api/Application/ApplicationManagerBase.cs

@@ -116,7 +116,7 @@ public ITask InitializeRepository()
                 .Then(GitClient.Commit("Initial commit", null))
                 .Then(_ =>
                 {
-                    Environment.InitializeRepository();
+                    Environment.InitializeRepository(CacheContainer);
                     RestartRepository();
                 })
                 .ThenInUI(InitializeUI);
@@ -214,6 +214,7 @@ public void Dispose()
         public ISettings LocalSettings { get; protected set; }
         public ISettings SystemSettings { get; protected set; }
         public ISettings UserSettings { get; protected set; }
+        public ICacheContainer CacheContainer { get; protected set; }
         public IUsageTracker UsageTracker { get; protected set; }
 
         protected TaskScheduler UIScheduler { get; private set; }

src/GitHub.Api/Application/IApplicationManager.cs

@@ -15,6 +15,7 @@ public interface IApplicationManager : IDisposable
         ISettings LocalSettings { get; }
         ISettings UserSettings { get; }
         ITaskManager TaskManager { get; }
+        ICacheContainer CacheContainer { get; }
         IGitClient GitClient { get; }
         IUsageTracker UsageTracker { get; }
 

src/GitHub.Api/Cache/CacheInterfaces.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+
+namespace GitHub.Unity
+{
+    public enum CacheType
+    {
+        BranchCache,
+        GitLogCache,
+        RepositoryInfoCache,
+        GitStatusCache,
+        GitLocksCache,
+        GitUserCache
+    }
+
+    public interface ICacheContainer
+    {
+        event Action<CacheType> CacheInvalidated;
+        event Action<CacheType, DateTimeOffset> CacheUpdated;
+
+        IBranchCache BranchCache { get; }
+        IGitLogCache GitLogCache { get; }
+        IRepositoryInfoCache RepositoryInfoCache { get; }
+        IGitStatusCache GitStatusCache { get; }
+        IGitLocksCache GitLocksCache { get; }
+        IGitUserCache GitUserCache { get; }
+        void Validate(CacheType cacheType);
+        void ValidateAll();
+        void Invalidate(CacheType cacheType);
+        void InvalidateAll();
+    }
+
+    public interface IManagedCache
+    {
+        event Action CacheInvalidated;
+        event Action<DateTimeOffset> CacheUpdated;
+
+        void ValidateData();
+        void InvalidateData();
+
+        DateTimeOffset LastUpdatedAt { get; }
+        DateTimeOffset LastVerifiedAt { get; }
+    }
+
+    public interface IGitLocks
+    {
+        List<GitLock> GitLocks { get; }
+    }
+
+    public interface IGitLocksCache : IManagedCache, IGitLocks
+    { }
+
+    public interface IGitUser
+    {
+        User User { get; }
+    }
+
+    public interface ITestCacheItem
+    { }
+
+    public interface IGitUserCache : IManagedCache, IGitUser
+    { }
+
+    public interface IGitStatus
+    {
+        GitStatus GitStatus { get; }
+    }
+
+    public interface IGitStatusCache : IManagedCache, IGitStatus
+    { }
+
+    public interface IRepositoryInfo
+    {
+        ConfigRemote? CurrentConfigRemote { get; set; }
+        ConfigBranch? CurentConfigBranch { get; set; }
+    }
+
+    public interface IRepositoryInfoCache : IManagedCache, IRepositoryInfo
+    {
+        GitRemote? CurrentGitRemote { get; set; }
+        GitBranch? CurentGitBranch { get; set; }
+    }
+
+    public interface IBranch
+    {
+        void UpdateData(List<GitBranch> localBranchUpdate, List<GitBranch> remoteBranchUpdate);
+        List<GitBranch> LocalBranches { get; }
+        List<GitBranch> RemoteBranches { get; }
+    }
+
+    public interface IBranchCache : IManagedCache, IBranch
+    { }
+
+    public interface IGitLogCache : IManagedCache
+    {
+        List<GitLogEntry> Log { get; }
+    }
+}

src/GitHub.Api/Git/GitBranch.cs

@@ -2,30 +2,12 @@
 
 namespace GitHub.Unity
 {
-    interface ITreeData
-    {
-        string Name { get; }
-        bool IsActive { get; }
-    }
-
     [Serializable]
-    public struct GitBranch : ITreeData
+    public struct GitBranch
     {
-        private string name;
-        private string tracking;
-        private bool active;
-        public string Name { get { return name; } }
-        public string Tracking { get { return tracking; } }
-        public bool IsActive { get { return active; } }
-
-        public GitBranch(string name, string tracking, bool active)
-        {
-            Guard.ArgumentNotNullOrWhiteSpace(name, "name");
-
-            this.name = name;
-            this.tracking = tracking;
-            this.active = active;
-        }
+        public string Name;
+        public string Tracking;
+        public bool IsActive;
 
         public override string ToString()
         {

src/GitHub.Api/Git/GitLogEntry.cs

@@ -42,7 +42,7 @@ public string PrettyTimeString
             }
         }
 
-        [NonSerialized] public DateTimeOffset? timeValue;
+        [NonSerialized] private DateTimeOffset? timeValue;
         public DateTimeOffset Time
         {
             get
@@ -56,7 +56,7 @@ public DateTimeOffset Time
             }
         }
 
-        [NonSerialized] public DateTimeOffset? commitTimeValue;
+        [NonSerialized] private DateTimeOffset? commitTimeValue;
         public DateTimeOffset? CommitTime
         {
             get

src/GitHub.Api/Git/Repository.cs

@@ -10,14 +10,13 @@ namespace GitHub.Unity
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
     class Repository : IEquatable<Repository>, IRepository
     {
-        private ConfigBranch? currentBranch;
         private IList<GitLock> currentLocks;
-        private ConfigRemote? currentRemote;
         private GitStatus currentStatus;
         private Dictionary<string, ConfigBranch> localBranches = new Dictionary<string, ConfigBranch>();
         private Dictionary<string, Dictionary<string, ConfigBranch>> remoteBranches = new Dictionary<string, Dictionary<string, ConfigBranch>>();
         private Dictionary<string, ConfigRemote> remotes;
         private IRepositoryManager repositoryManager;
+        private ICacheContainer cacheContainer;
         public event Action<string> OnCurrentBranchChanged;
         public event Action<string> OnCurrentRemoteChanged;
         public event Action OnCurrentBranchUpdated;
@@ -33,22 +32,24 @@ class Repository : IEquatable<Repository>, IRepository
         /// </summary>
         /// <param name="name">The repository name.</param>
         /// <param name="localPath"></param>
-        public Repository(string name, NPath localPath)
+        /// <param name="container"></param>
+        public Repository(string name, NPath localPath, ICacheContainer container)
         {
             Guard.ArgumentNotNullOrWhiteSpace(name, nameof(name));
             Guard.ArgumentNotNull(localPath, nameof(localPath));
 
             Name = name;
             LocalPath = localPath;
-            this.User = new User();
+            User = new User();
+
+            cacheContainer = container;
         }
 
-        public void Initialize(IRepositoryManager repositoryManager)
+        public void Initialize(IRepositoryManager initRepositoryManager)
         {
-            Guard.ArgumentNotNull(repositoryManager, nameof(repositoryManager));
-
-            this.repositoryManager = repositoryManager;
+            Guard.ArgumentNotNull(initRepositoryManager, nameof(initRepositoryManager));
 
+            repositoryManager = initRepositoryManager;
             repositoryManager.OnCurrentBranchUpdated += RepositoryManager_OnCurrentBranchUpdated;
             repositoryManager.OnCurrentRemoteUpdated += RepositoryManager_OnCurrentRemoteUpdated;
             repositoryManager.OnStatusUpdated += status => CurrentStatus = status;
@@ -170,31 +171,31 @@ public bool Equals(IRepository other)
 
         private void RepositoryManager_OnCurrentRemoteUpdated(ConfigRemote? remote)
         {
-            if (!Nullable.Equals(currentRemote, remote))
+            if (!Nullable.Equals(CurrentConfigRemote, remote))
             {
-                currentRemote = remote;
+                CurrentConfigRemote = remote;
 
-                Logger.Trace("OnCurrentRemoteChanged: {0}", currentRemote.HasValue ? currentRemote.Value.ToString() : "[NULL]");
-                OnCurrentRemoteChanged?.Invoke(currentRemote.HasValue ? currentRemote.Value.Name : null);
+                Logger.Trace("OnCurrentRemoteChanged: {0}", remote.HasValue ? remote.Value.ToString() : "[NULL]");
+                OnCurrentRemoteChanged?.Invoke(remote.HasValue ? remote.Value.Name : null);
 
                 UpdateRepositoryInfo();
             }
         }
 
         private void RepositoryManager_OnCurrentBranchUpdated(ConfigBranch? branch)
         {
-            if (!Nullable.Equals(currentBranch, branch))
+            if (!Nullable.Equals(CurrentConfigBranch, branch))
             {
-                currentBranch = branch;
+                CurrentConfigBranch = branch;
 
-                Logger.Trace("OnCurrentBranchChanged: {0}", currentBranch.HasValue ? currentBranch.ToString() : "[NULL]");
-                OnCurrentBranchChanged?.Invoke(currentBranch.HasValue ? currentBranch.Value.Name : null);
+                Logger.Trace("OnCurrentBranchChanged: {0}", branch.HasValue ? branch.ToString() : "[NULL]");
+                OnCurrentBranchChanged?.Invoke(branch.HasValue ? branch.Value.Name : null);
             }
         }
 
         private void RepositoryManager_OnLocalBranchUpdated(string name)
         {
-            if (name == currentBranch?.Name)
+            if (name == CurrentConfigBranch?.Name)
             {
                 Logger.Trace("OnCurrentBranchUpdated: {0}", name);
                 OnCurrentBranchUpdated?.Invoke();
@@ -325,17 +326,25 @@ private GitBranch GetLocalGitBranch(ConfigBranch x)
         {
             var name = x.Name;
             var trackingName = x.IsTracking ? x.Remote.Value.Name + "/" + name : "[None]";
-            var isActive = name == currentBranch?.Name;
+            var isActive = name == CurrentConfigBranch?.Name;
 
-            return new GitBranch(name, trackingName, isActive);
+            return new GitBranch {
+                Name = name,
+                Tracking = trackingName,
+                IsActive = isActive
+            };
         }
 
         private GitBranch GetRemoteGitBranch(ConfigBranch x)
         {
             var name = x.Remote.Value.Name + "/" + x.Name;
             var trackingName = "[None]";
 
-            return new GitBranch(name, trackingName, false);
+            return new GitBranch {
+                Name = name,
+                Tracking = trackingName,
+                IsActive = false
+            };
         }
 
         private GitRemote GetGitRemote(ConfigRemote configRemote)
@@ -349,34 +358,35 @@ private GitRemote GetGitRemote(ConfigRemote configRemote)
 
         public IEnumerable<GitBranch> RemoteBranches => remoteBranches.Values.SelectMany(x => x.Values).Select(GetRemoteGitBranch);
 
-        public GitBranch? CurrentBranch
+        private ConfigBranch? CurrentConfigBranch
         {
-            get
+            get { return this.cacheContainer.RepositoryInfoCache.CurentConfigBranch; }
+            set
             {
-                if (currentBranch != null)
-                {
-                    return GetLocalGitBranch(currentBranch.Value);
-                }
-
-                return null;
+                cacheContainer.RepositoryInfoCache.CurentConfigBranch = value;
+                cacheContainer.RepositoryInfoCache.CurentGitBranch = value != null
+                    ? (GitBranch?)GetLocalGitBranch(value.Value)
+                    : null;
             }
         }
 
-        public string CurrentBranchName => currentBranch?.Name;
-
-        public GitRemote? CurrentRemote
+        private ConfigRemote? CurrentConfigRemote
         {
-            get
-            {
-                if (currentRemote != null)
-                {
-                    return GetGitRemote(currentRemote.Value);
-                }
-
-                return null;
+            get { return this.cacheContainer.RepositoryInfoCache.CurrentConfigRemote; }
+            set {
+                cacheContainer.RepositoryInfoCache.CurrentConfigRemote = value;
+                cacheContainer.RepositoryInfoCache.CurrentGitRemote = value != null
+                    ? (GitRemote?) GetGitRemote(value.Value)
+                    : null;
             }
         }
 
+        public GitBranch? CurrentBranch => cacheContainer.RepositoryInfoCache.CurentGitBranch;
+
+        public string CurrentBranchName => CurrentConfigBranch?.Name;
+
+        public GitRemote? CurrentRemote => cacheContainer.RepositoryInfoCache.CurrentGitRemote;
+
         public UriString CloneUrl { get; private set; }
 
         public string Name { get; private set; }
@@ -432,7 +442,7 @@ public interface IUser
     }
 
     [Serializable]
-    class User : IUser
+    public class User : IUser
     {
         public override string ToString()
         {

src/GitHub.Api/Git/RepositoryManager.cs

@@ -457,11 +457,16 @@ private void UpdateCurrentBranchAndRemote(string head)
                 }
             }
 
-            Logger.Trace("OnCurrentBranchUpdated: {0}", branch.HasValue ? branch.Value.ToString() : "[NULL]");
-            OnCurrentBranchUpdated?.Invoke(branch);
+            new ActionTask(taskManager.Token, () => {
+                Logger.Trace("OnCurrentBranchUpdated: {0}", branch.HasValue ? branch.Value.ToString() : "[NULL]");
+                OnCurrentBranchUpdated?.Invoke(branch);
 
-            Logger.Trace("OnCurrentRemoteUpdated: {0}", remote.HasValue ? remote.Value.ToString() : "[NULL]");
-            OnCurrentRemoteUpdated?.Invoke(remote);
+                Logger.Trace("OnCurrentRemoteUpdated: {0}", remote.HasValue ? remote.Value.ToString() : "[NULL]");
+                OnCurrentRemoteUpdated?.Invoke(remote);
+            })
+            {
+                Affinity = TaskAffinity.UI
+            }.Start();
         }
 
         private void Watcher_OnIndexChanged()