Splits CachedPathSuggestBoxDemo into two projects and deletes original.

Moves validation to CollectionEmptyValidationRule.
User NameOf Markup to assign ValuePath to SuggestBox.
Improves logic for retrieving cached paths as well as file-system paths.
Removes use of DataTemplateSelector; and replaces with more informative datatemplates
Uses Net 5.

Author: Declan Taylor

source/Demos/CachedPathSuggest/CachedPathSuggest.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>net5.0</TargetFramework>
+		<Nullable>enable</Nullable>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="LiteDB" Version="5.0.11" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\Infrastructure\Infrastructure.csproj" />
+	</ItemGroup>
+
+</Project>

source/Demos/CachedPathSuggest/Infrastructure/DirectoryHelper.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace CachedPathSuggest.Infrastructure
+{
+    internal static class DirectoryHelper
+    {
+        public static IEnumerable<(string path, string? label)>? EnumerateSubDirectories(string input)
+        {
+            var subDirs = EnumerateLogicalDriveOrSubDirectories(input);
+
+            // ReSharper disable PossibleMultipleEnumeration
+            return subDirs != null
+                ? subDirs.Any() 
+                ? subDirs.Select(a => (a, (string?)null)) : EnumerateChildren(input)
+                : new[] { (input, (string?)"Unauthorized Access") };
+
+            // Find last separator and list directories underneath with * search-pattern
+            static IEnumerable<(string, string?)> EnumerateChildren(string input)
+            {
+                var sepIdx = input.LastIndexOf('\\');
+
+                if (sepIdx >= input.Length)
+                    return EnumerateLogicalDrives();
+
+                string folder = input.Substring(0, sepIdx + 1);
+                string searchPattern = input.Substring(sepIdx + 1) + "*";
+                try
+                {
+                    return Directory
+                            .GetDirectories(folder, searchPattern)
+                            .Select(a => (a, (string?)null)).ToList();
+                }
+                catch
+                {
+                    // Catch invalid path exceptions here ...
+                    return EnumerateLogicalDrives();
+                }
+            }
+
+            static IEnumerable<string>? EnumerateLogicalDriveOrSubDirectories(string testDrive)
+            {
+                if (testDrive.Length < 3) return Enumerate(testDrive);
+
+                return Directory.Exists(testDrive) ? TryGetDirectories(testDrive) : Array.Empty<string>();
+
+                static string[]? TryGetDirectories(string testDrive)
+                {
+                    try
+                    {
+                        return Directory.GetDirectories(testDrive);
+                    }
+                    catch (UnauthorizedAccessException)
+                    {
+                        return null;
+                    }
+                }
+
+                static IEnumerable<string>? Enumerate(string input)
+                {
+                    return (input.Length, input.TryGetUpper(0), input.TryGetUpper(1), input.TryGetUpper(2)) switch
+                    {
+                        (1, >= 'A' and <= 'Z', _, _) => new[] { input + ":\\" }.Concat(EnumerateLogicalDriveOrSubDirectories(input + ":\\") ?? Array.Empty<string>()),
+                        (2, >= 'A' and <= 'Z', ':', _) => new[] { input + ":\\" }.Concat(EnumerateLogicalDriveOrSubDirectories(input + "\\") ?? Array.Empty<string>()),
+                        (3, >= 'A' and <= 'Z', ':', '\\') => EnumerateLogicalDriveOrSubDirectories(input),
+                        _ => Array.Empty<string>()
+                    };
+                }
+            }
+        }
+
+        public static IEnumerable<(string path, string? label)> EnumerateLogicalDrives()
+        {
+            foreach (var driveName in Environment.GetLogicalDrives())
+            {
+                if (string.IsNullOrEmpty(driveName))
+                    continue;
+
+                string? volumeLabel = null;
+
+                try
+                {
+                    if (new DriveInfo(driveName) is { IsReady: true } driveInfo)
+                        volumeLabel = driveInfo.VolumeLabel;
+                }
+                catch (IOException)
+                {
+                    // network path not found
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    // can't access path
+                }
+
+                yield return (driveName, volumeLabel);
+            }
+        }
+    }
+
+    internal static class StringHelper
+    {
+        public static char TryGetUpper(this string value, int index)
+        {
+            return char.ToUpper(value.ElementAtOrDefault(index));
+        }
+    }
+}

source/Demos/CachedPathSuggest/Infrastructure/LiteRepository.cs

@@ -0,0 +1,85 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using LiteDB;
+
+namespace CachedPathSuggest.Infrastructure
+{
+    /// <summary>
+    ///     Implements a static service provider for searching and editing a LiteDB file.
+    /// </summary>
+    public class LiteRepository
+    {
+        private const string DbPath = @"..\..\..\Data\KeyValue.litedb";
+
+        // Collection needs a name because object, keyvaluepair<string,string> is generic.
+        private const string CollectionName = "collection";
+
+        /// <summary>
+        ///     Class constructor
+        /// </summary>
+        public LiteRepository()
+        {
+            (Directory.GetParent(DbPath) ?? throw new Exception("Can't create directory")).Create();
+            BsonMapper.Global.Entity<KeyValuePair<string, DateTime>>().Id(x => x.Key);
+        }
+
+        public event Action? Change;
+
+        /// <summary>
+        ///     Inserts a new string into the collection of bookmarked strings.
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="collectionName"></param>
+        public void Insert(string key, string? collectionName = null)
+        {
+            using var db = new LiteDatabase(DbPath);
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+            col.Upsert(new KeyValuePair<string, DateTime>(key, DateTime.Now));
+            Change?.Invoke();
+        }
+
+        /// <summary>
+        ///     Inserts a new string into the collection of bookmarked strings.
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="collectionName"></param>
+        public void Remove(string key, string? collectionName = null)
+        {
+            using var db = new LiteDatabase(DbPath);
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+
+            // Make sure string is already present
+            if (col.FindOne(x => x.Key == key) is { } one)
+                col.Delete(key);
+
+            Change?.Invoke();
+        }
+
+        /// <summary>
+        /// </summary>
+        public KeyValuePair<string, DateTime>? Find(string key, string? collectionName = null)
+        {
+            using var db = new LiteDatabase(DbPath);
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+            var one = col.FindOne(x => x.Key == key);
+            return one;
+        }
+
+        /// <summary>
+        ///     Filters the collection of bookmark strings by the given string and
+        ///     returns the resulting collection.
+        /// </summary>
+        public IEnumerable<KeyValuePair<string, DateTime>> Filter(string key, string? collectionName = null)
+        {
+            using var db = new LiteDatabase(DbPath);
+            var col = db.GetCollection<KeyValuePair<string, DateTime>>(collectionName ?? CollectionName);
+            return string.IsNullOrWhiteSpace(key)
+                ? col.Query().ToArray()
+                : col.Find(Query.Contains(nameof(KeyValuePair<string, DateTime>.Key), key)).ToArray();
+        }
+    }
+}

source/Demos/CachedPathSuggest/Service/CachedPathInformationSuggest.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using CachedPathSuggest.Infrastructure;
+using CachedPathSuggest.ViewModels;
+
+namespace CachedPathSuggest.Service
+{
+    /// <summary>
+    ///     Wraps a LiteDB to generate previously bookmarked suggestions through similarity for a given string.
+    /// </summary>
+    public class CachedPathInformationAsyncSuggest : IAsyncSuggest
+    {
+        private static readonly int NumberOfResultsToReturn = 5;
+        private readonly LiteRepository repository;
+
+        public CachedPathInformationAsyncSuggest(LiteRepository repository)
+        {
+            this.repository = repository;
+        }
+
+        /// <summary>
+        ///     Makes suggestions of paths based on match between query and the full-name of the path.
+        ///     Only returns latest <see cref="NumberOfResultsToReturn" /> results (newest first).
+        /// </summary>
+        /// <inheritdoc cref="SuggestAsync" />
+        /// <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<IReadOnlyCollection<BaseItem>?> SuggestAsync(string queryThis)
+        {
+            return await Task.Run(() => GetPathInformations(queryThis, repository));
+
+            static CachedPathInformation[] GetPathInformations(string key, LiteRepository repository)
+            {
+                return repository
+                    .Filter(key)
+                    .Take(NumberOfResultsToReturn)
+                    .OrderByDescending(a => a.Value)
+                    .Select(a => new CachedPathInformation(a.Value, a.Key))
+                    .ToArray();
+            }
+        }
+
+        public void Insert(string path)
+        {
+            var fileInfo = new FileInfo(path);
+            if (fileInfo.Exists) repository.Insert(fileInfo.FullName);
+
+            var directoryInfo = new DirectoryInfo(path);
+            if (!directoryInfo.Exists)
+                throw new Exception("Path does not exist");
+            repository.Insert(directoryInfo.FullName);
+        }
+
+        internal void Delete(string text)
+        {
+            repository.Remove(text);
+        }
+
+        internal bool Match(string text)
+        {
+            return repository.Find(text) is not {Key: null};
+        }
+    }
+}

source/Demos/CachedPathSuggest/Service/CombinedSuggest.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using CachedPathSuggest.Infrastructure;
+using CachedPathSuggest.ViewModels;
+
+namespace CachedPathSuggest.Service
+{
+    /// <summary>
+    ///     Wraps a LiteDB and a FileSystem data provider to generate similarity based suggestions
+    ///     for a given string.
+    /// </summary>
+    public class CombinedAsyncSuggest : IAsyncSuggest
+    {
+        private readonly CachedPathInformationAsyncSuggest
+            cachedPathInformationAsyncSuggest = new(new LiteRepository());
+
+        private readonly DirectoryAsyncSuggest directoryAsyncSuggest = new();
+
+        /// <summary>
+        ///     Gets a list of combined suggestions based on string similarity from the:
+        ///     1) cached entries (bookmarks) and
+        ///     2) file system data provider.
+        /// </summary>
+        /// <param name="queryThis"></param>
+        /// <returns>
+        ///     Both types (cached entries and file system provider entries) of entries are returned
+        ///     in a single list. The list contains a separator item (if both types of items are returned).
+        ///     The separator item can be used for visual enhancement when displaying the list.
+        /// </returns>
+        public async Task<IReadOnlyCollection<BaseItem>?> SuggestAsync(string queryThis)
+        {
+            var cachedSuggestions = await cachedPathInformationAsyncSuggest.SuggestAsync(queryThis);
+            var directorySuggestions = await directoryAsyncSuggest.SuggestAsync(queryThis);
+            return (cachedSuggestions, directorySuggestions) switch
+            {
+                (null, null) => null,
+                ({Count: 0}, {Count: 0}) => null,
+                ({Count: 0}, {Count: > 0}) => directorySuggestions,
+                ({Count: > 0}, {Count: 0}) => cachedSuggestions,
+                ({Count: > 0} c, {Count: > 0} d) => c
+                    .Concat(new[] {new ItemSeparator()}).Concat(d).ToArray(),
+                _ => throw new ArgumentOutOfRangeException()
+            };
+        }
+
+        /// <summary>
+        ///     Insert a new suggestion into the available list of suggestions
+        /// </summary>
+        /// <param name="text"></param>
+        public void AddCachedSuggestion(string text)
+        {
+            cachedPathInformationAsyncSuggest.Insert(text);
+        }
+
+        /// <summary>
+        ///     Delete a suggestion in the available list of suggestions
+        /// </summary>
+        /// <param name="text"></param>
+        public void RemoveCachedSuggestion(string text)
+        {
+            cachedPathInformationAsyncSuggest.Delete(text);
+        }
+
+        /// <summary>
+        ///     Insert a new suggestion into the available list of suggestions
+        /// </summary>
+        /// <param name="text"></param>
+        public bool ContainsSuggestion(string text)
+        {
+            return cachedPathInformationAsyncSuggest.Match(text);
+        }
+    }
+}