Changed logic for filtering PathInformation for cached data - now matches based on FullName.

Cached data is returned in descending order of search time.
Divided classes into separate files.

Author: Declan Taylor

source/Demos/CachedPathSuggestBoxDemo/CachedPathSuggestBoxDemo.csproj

@@ -14,4 +14,8 @@
     <ProjectReference Include="..\..\SuggestBoxLib\SuggestBoxLib.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Data\" />
+  </ItemGroup>
+
 </Project>

source/Demos/CachedPathSuggestBoxDemo/Infrastructure/CachedPathInformationSuggest.cs

@@ -0,0 +1,55 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace CachedPathSuggestBoxDemo.Infrastructure
+{
+
+
+    public class CachedPathInformationSuggest :ISuggest
+    {
+        public void Insert(string path)
+        {
+            var fileInfo =new FileInfo(path);
+            if (fileInfo.Exists)
+            {
+                LiteRepository.Instance.Insert(fileInfo.FullName);
+            }
+
+            var directoryInfo = new DirectoryInfo(path);
+            if (!directoryInfo.Exists) return;
+            LiteRepository.Instance.Insert(directoryInfo.FullName);
+        }
+
+        /// <summary>
+        /// Makes suggestions of paths based on match between query and the name of the path.
+        /// Only returns latest 3 results. Newest first.
+        /// </summary>
+        /// <inheritdoc cref="MakeSuggestions"/>
+        /// <example>
+        /// <see cref="queryThis"/> : doc
+        /// will match with
+        /// c:\\Documents
+        /// t:\\files\store\doC.xaml
+        /// but not
+        /// f:\\do_letters
+        /// g:\\document\lists.ico
+        /// </example>
+        public async Task<IEnumerable<object>?> MakeSuggestions(string queryThis)
+        {
+            return await Task.Run(() => MakeSuggestionsPrivate(queryThis).ToArray());
+
+            IEnumerable<object> MakeSuggestionsPrivate(string queryThis) => from item in GetPathInformations(queryThis)
+                where item.Name.Contains(queryThis, StringComparison.CurrentCultureIgnoreCase)
+                select new { Header = item.FullName, Value = item.FullName };
+
+            static PathInformation[] GetPathInformations(string key)
+            {
+                return LiteRepository.Instance.Filter(key).OrderByDescending(a => a.Value).Take(5).Select(a => new PathInformation(a.Key)).ToArray();
+            }
+        }
+    }
+}

source/Demos/CachedPathSuggestBoxDemo/Infrastructure/DirectorySuggestSource.cs

@@ -13,7 +13,7 @@ namespace CachedPathSuggestBoxDemo.Infrastructure
     /// Defines a suggestion object to generate suggestions
     /// based on sub entries of specified string.
     /// </summary>
-    public class DirectorySuggestSource
+    public class DirectorySuggest : ISuggest
     {
         #region fields
         private readonly Dictionary<string, CancellationTokenSource> _Queue;
@@ -24,7 +24,7 @@ public class DirectorySuggestSource
         /// <summary>
         /// Class constructor
         /// </summary>
-        public DirectorySuggestSource()
+        public DirectorySuggest()
         {
             _Queue = new Dictionary<string, CancellationTokenSource>();
             _SlowStuffSemaphore = new SemaphoreSlim(1, 1);
@@ -69,14 +69,14 @@ public DirectorySuggestSource()
 
 
 
-            static IEnumerable<object> EnumerateSubDirs(string input)
+            static IEnumerable<object>? EnumerateSubDirs(string input)
             {
                 if (string.IsNullOrEmpty(input))
                     return EnumerateLogicalDrives();
 
                 var subDirs = EnumerateLogicalDriveOrSubDirs(input, input);
 
-                return subDirs ?? Get();
+                return subDirs!=null? subDirs.Any()? subDirs: Get():null;
 
                 // Find last separator and list directories underneath
                 // with * search-pattern
@@ -90,7 +90,7 @@ IEnumerable<object> Get()
                     string[]? directories = null;
                     try
                     {
-                        directories = System.IO.Directory.GetDirectories(folder, searchPattern);
+                        directories = Directory.GetDirectories(folder, searchPattern);
                     }
                     catch
                     {
@@ -161,21 +161,38 @@ static IEnumerable<object> EnumerateLogicalDrives()
 
             static IEnumerable<object>? EnumerateLogicalDriveOrSubDirs(string testDrive, string input)
             {
-                return System.IO.Directory.Exists(testDrive) != true ?
-                    null :
-                    GetLogicalDriveOrSubDirs2(testDrive, input);
-
-                static IEnumerable<object>  GetLogicalDriveOrSubDirs2(string testDrive, string input)
+                return System.IO.Directory.Exists(testDrive) ?
+                    GetDirectories(testDrive) is {} array?
+                    GetLogicalDriveOrSubDirs2(testDrive, input, array):
+                    null:
+                    null;
+                   
+
+                static IEnumerable<object>?  GetLogicalDriveOrSubDirs2(string testDrive, string input, IEnumerable<string> directories)
                 {
                     // List the drive itself if there was only 1 or 2 letters
                     // since this is not a valid drive and we don'nt know if the user
                     // wants to go to the drive or a folder contained in it
                     if (input.Length <= 2)
                         yield return new {Header = testDrive, Value = testDrive};
 
-                    // and list all sub-directories of that drive
-                    foreach (var item in System.IO.Directory.GetDirectories(testDrive))
-                        yield return new {Header = item, Value = item};
+                    foreach (var item in directories)
+                        yield return new { Header = item, Value = item };
+                }
+
+                static string[]? GetDirectories(string testDrive)
+                {
+                    string[] directories;
+                    try
+                    {
+                        directories = Directory.GetDirectories(testDrive);
+                    }
+                    catch (UnauthorizedAccessException)
+                    {
+                        return null;
+                    }
+
+                    return directories;
                 }
             }
         }

source/Demos/CachedPathSuggestBoxDemo/Infrastructure/ISuggest.cs

@@ -0,0 +1,15 @@
+#nullable enable
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace CachedPathSuggestBoxDemo.Infrastructure
+{
+    public interface ISuggest
+    {
+        /// <summary>
+        /// Makes suggestions based on <see cref="queryThis"/>
+        /// </summary>
+        Task<IEnumerable<object>?> MakeSuggestions(string queryThis);
+    }
+}

source/Demos/CachedPathSuggestBoxDemo/Infrastructure/LiteRepository.cs

@@ -1,35 +1,12 @@
-using System;
+#nullable enable
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using LiteDB;
 
 namespace CachedPathSuggestBoxDemo.Infrastructure
 {
-
-    public class SuggestionProvider 
-    {
-        private Lazy<PathInformation[]> filesCache => new Lazy<PathInformation[]>(() =>
-        {
-            var folders = LiteRepository.Instance.SelectAll();
-            return folders.Select(a => new PathInformation(a.Value)).ToArray();
-        });
-
-        public IEnumerable<PathInformation> Collection => filesCache.Value;
-
-        public void Insert(string path)
-        {
-            var fileInfo =new FileInfo(path);
-            if(fileInfo.Exists)
-            LiteRepository.Instance.Insert(fileInfo.Name,fileInfo.FullName);
-
-            var directoryInfo = new DirectoryInfo(path);
-            if (directoryInfo.Exists)
-                LiteRepository.Instance.Insert(directoryInfo.Name, directoryInfo.FullName);
-        }
-    }
-
-
     public sealed class LiteRepository
     {
         private const string DbPath = @"..\..\..\Data\KeyValue.litedb";
@@ -43,18 +20,20 @@ static LiteRepository()
         {
         }
 
-        public void Insert(string k, string value, string collectionName = null)
+        public void Insert(string k, string? collectionName = null)
         {
             using var db = new LiteDatabase(DbPath);
-            var col = db.GetCollection<KeyValuePair<string, string>>(collectionName ??= CollectionName);
-            col.Upsert(new KeyValuePair<string, string>(k, value));
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+            col.Upsert(new KeyValuePair<string, DateTime>(k, DateTime.Now));
         }
 
-        public IEnumerable<KeyValuePair<string, string>> SelectAll(string collectionName = null)
+        public IEnumerable<KeyValuePair<string, DateTime>> Filter(string key, string? collectionName = null)
         {
             using var db = new LiteDatabase(DbPath);
-            var col = db.GetCollection<KeyValuePair<string, string>>(collectionName ??= CollectionName);
-            return col.Query().ToArray();
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+            return string.IsNullOrEmpty(key)?
+                new KeyValuePair<string, DateTime>[]{}:
+                col.Find(Query.Contains(nameof(KeyValuePair<string, DateTime>.Key), key)).ToArray();
         }
 
         private LiteRepository()
@@ -69,45 +48,4 @@ private LiteRepository()
 
         public static LiteRepository Instance { get; } = new LiteRepository();
     }
-
-
-
-    public class PathInformation : IEquatable<PathInformation>
-    {
-        public PathInformation(string argValue)
-        {
-            if (new DirectoryInfo(argValue).Parent == null)
-            {
-                Name = argValue;
-            }
-            else
-                Name = System.IO.Path.GetFileName(argValue);
-            FullName = argValue;
-        }
-
-        public string Name { get; }
-
-        public string FullName { get; }
-
-
-        public bool Equals(PathInformation other)
-        {
-            if (ReferenceEquals(null, other)) return false;
-            if (ReferenceEquals(this, other)) return true;
-            return Name == other.Name && FullName == other.FullName;
-        }
-
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(null, obj)) return false;
-            if (ReferenceEquals(this, obj)) return true;
-            if (obj.GetType() != this.GetType()) return false;
-            return Equals((PathInformation)obj);
-        }
-
-        public override int GetHashCode()
-        {
-            return HashCode.Combine(Name, FullName);
-        }
-    }
 }

source/Demos/CachedPathSuggestBoxDemo/Infrastructure/PathInformation.cs

@@ -0,0 +1,39 @@
+using System;
+using System.IO;
+
+namespace CachedPathSuggestBoxDemo.Infrastructure
+{
+    public class PathInformation : IEquatable<PathInformation>
+    {
+        public PathInformation(string argValue)
+        {
+            Name = new DirectoryInfo(argValue).Parent == null ? argValue : Path.GetFileName(argValue);
+            FullName = argValue;
+        }
+
+        public string Name { get; }
+
+        public string FullName { get; }
+
+
+        public bool Equals(PathInformation other)
+        {
+            if (ReferenceEquals(null, other)) return false;
+            if (ReferenceEquals(this, other)) return true;
+            return Name == other.Name && FullName == other.FullName;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((PathInformation)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Name, FullName);
+        }
+    }
+}

source/Demos/CachedPathSuggestBoxDemo/MainWindow.xaml

@@ -15,6 +15,7 @@
                                   Width="400"
                                   x:Name="DiskPathSuggestBox"
                                   Hint="Enter a file system path"
+                                  FontSize="14"
                                   Text="{Binding Text}"
                                   Margin="5" />
         <Button Width="100" Grid.Column="1" Content="Save" FontSize="20" FontWeight="Bold" Margin="5" Click="ButtonBase_OnClick">

source/Demos/CachedPathSuggestBoxDemo/MainWindow.xaml.cs

@@ -11,16 +11,16 @@ namespace CachedPathSuggestBoxDemo
     /// </summary>
     public partial class MainWindow : Window
     {
-        DirectorySuggestSource source = new DirectorySuggestSource();
-        FastObservableCollection<object> _ListQueryResult = new FastObservableCollection<object>();
-        SuggestionProvider folderSuggestionProvider =new SuggestionProvider();
+        private readonly DirectorySuggest directorySuggest = new DirectorySuggest();
+        private readonly FastObservableCollection<object> listQueryResult = new FastObservableCollection<object>();
+        public readonly CachedPathInformationSuggest cachedPathInformationSuggest =new CachedPathInformationSuggest();
 
         public MainWindow()
         {
             InitializeComponent();
 
             this.DiskPathSuggestBox.TextChangedCommand = new RelayCommand<object>(Execute); ;
-            this.DiskPathSuggestBox.ItemsSource = _ListQueryResult;
+            this.DiskPathSuggestBox.ItemsSource = listQueryResult;
             this.DiskPathSuggestBox.DataContext = this;
 
         }
@@ -36,26 +36,28 @@ private async void Execute(object p)
             if (!(p is string newText))
                 return;
 
-            var suggestions1 = folderSuggestionProvider.Collection.Where(a => a.Name.Contains(newText, StringComparison.CurrentCultureIgnoreCase)).ToArray();
+            var suggestions2 = await directorySuggest.MakeSuggestions(newText);
 
-            var suggestions = await source.MakeSuggestions(newText);
-
-            _ListQueryResult.Clear();
-            if (suggestions == null&& suggestions1.Any()==false)
+            listQueryResult.Clear();
+            if (suggestions2 == null)
+            {
+                this.DiskPathSuggestBox.ValidText = false;
                 return;
+            }
+            this.DiskPathSuggestBox.ValidText = true;
+
+            var suggestions1 = await cachedPathInformationSuggest.MakeSuggestions(newText);
 
             var enumerable = suggestions1
-                                        .Select(a => new { Header = a.FullName, Value = a.FullName })
-                                        .Concat(suggestions as object[] ?? suggestions?? new List<object>())
+                                        .Concat(suggestions2)
                                         .ToArray();
 
-            this.DiskPathSuggestBox.ValidText = enumerable.Any();
-            _ListQueryResult.AddItems(enumerable);
+            listQueryResult.AddItems(enumerable);
         }
 
         private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
         {
-            folderSuggestionProvider.Insert(Text);
+            cachedPathInformationSuggest.Insert(Text);
         }
     }
 }