Update TFM's to remove Net 7.0 (#954)

Fix Package Icon from Url to use local resource Include Readme in package Update code to use latest coding optimisations
reactiveui · Sep 12, 2024 · 59922a0 · 59922a0
1 parent 0f8294d
commit 59922a0
Show file tree

Hide file tree

Showing 24 changed files with 392 additions and 96 deletions.
diff --git a/Images/logo.png b/Images/logo.png
diff --git a/src/Akavache.Core/BlobCache/CacheEntry.cs b/src/Akavache.Core/BlobCache/CacheEntry.cs
@@ -17,7 +17,6 @@ namespace Akavache;
 /// <param name="expiresAt">The date and time when the entry expires.</param>
 public class CacheEntry(string? typeName, byte[] value, DateTimeOffset createdAt, DateTimeOffset? expiresAt)
 {
-
     /// <summary>
     /// Gets or sets the date and time when the entry was created.
     /// </summary>

diff --git a/src/Akavache.Core/BlobCache/IObjectWrapper.cs b/src/Akavache.Core/BlobCache/IObjectWrapper.cs
@@ -8,6 +8,4 @@ namespace Akavache;
 /// <summary>
 /// A wrapper around a object.
 /// </summary>
-internal interface IObjectWrapper
-{
-}
+internal interface IObjectWrapper;
diff --git a/src/Akavache.Core/BlobCache/ISecureBlobCache.cs b/src/Akavache.Core/BlobCache/ISecureBlobCache.cs
@@ -15,6 +15,4 @@ namespace Akavache;
 /// saved to disk cannot be easily read by a third party.
 /// </para>
 /// </summary>
-public interface ISecureBlobCache : IBlobCache
-{
-}
+public interface ISecureBlobCache : IBlobCache;
diff --git a/src/Akavache.Core/BlobCache/InMemoryBlobCache.cs b/src/Akavache.Core/BlobCache/InMemoryBlobCache.cs
@@ -59,7 +59,7 @@ public InMemoryBlobCache(IEnumerable<KeyValuePair<string, byte[]>> initialConten
     public InMemoryBlobCache(IScheduler? scheduler, IEnumerable<KeyValuePair<string, byte[]>>? initialContents)
     {
         Scheduler = scheduler ?? CurrentThreadScheduler.Instance;
-        foreach (var item in initialContents ?? Enumerable.Empty<KeyValuePair<string, byte[]>>())
+        foreach (var item in initialContents ?? [])
         {
             _cache[item.Key] = new(null, item.Value, Scheduler.Now, null);
         }
@@ -155,7 +155,7 @@ public IObservable<Unit> Insert(string key, byte[] data, DateTimeOffset? absolut
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>(nameof(InMemoryBlobCache));
         }
 
         lock (_cache)
@@ -168,15 +168,15 @@ public IObservable<Unit> Insert(string key, byte[] data, DateTimeOffset? absolut
 
     /// <inheritdoc />
     public IObservable<Unit> Flush() => _disposed ?
-        ExceptionHelper.ObservableThrowObjectDisposedException<Unit>("InMemoryBlobCache") :
+        ExceptionHelper.ObservableThrowObjectDisposedException<Unit>(nameof(InMemoryBlobCache)) :
         Observable.Return(Unit.Default);
 
     /// <inheritdoc />
     public IObservable<byte[]> Get(string key)
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<byte[]>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<byte[]>(nameof(InMemoryBlobCache));
         }
 
         CacheEntry? entry;
@@ -211,7 +211,7 @@ public IObservable<byte[]> Get(string key)
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<DateTimeOffset?>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<DateTimeOffset?>(nameof(InMemoryBlobCache));
         }
 
         CacheEntry? entry;
@@ -233,7 +233,7 @@ public IObservable<IEnumerable<string>> GetAllKeys()
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<List<string>>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<List<string>>(nameof(InMemoryBlobCache));
         }
 
         lock (_cache)
@@ -250,7 +250,7 @@ public IObservable<Unit> Invalidate(string key)
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>(nameof(InMemoryBlobCache));
         }
 
         lock (_cache)
@@ -266,7 +266,7 @@ public IObservable<Unit> InvalidateAll()
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>(nameof(InMemoryBlobCache));
         }
 
         lock (_cache)
@@ -282,7 +282,7 @@ public IObservable<Unit> InsertObject<T>(string key, T value, DateTimeOffset? ab
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>(nameof(InMemoryBlobCache));
         }
 
         var data = SerializeObject(value);
@@ -300,7 +300,7 @@ public IObservable<T> GetObject<T>(string key)
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<T>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<T>(nameof(InMemoryBlobCache));
         }
 
         CacheEntry? entry;
@@ -340,7 +340,7 @@ public IObservable<IEnumerable<T>> GetAllObjects<T>()
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<IEnumerable<T>>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<IEnumerable<T>>(nameof(InMemoryBlobCache));
         }
 
         lock (_cache)
@@ -356,15 +356,15 @@ public IObservable<IEnumerable<T>> GetAllObjects<T>()
 
     /// <inheritdoc />
     public IObservable<Unit> InvalidateObject<T>(string key) => _disposed ?
-        ExceptionHelper.ObservableThrowObjectDisposedException<Unit>("InMemoryBlobCache") :
+        ExceptionHelper.ObservableThrowObjectDisposedException<Unit>(nameof(InMemoryBlobCache)) :
         Invalidate(key);
 
     /// <inheritdoc />
     public IObservable<Unit> InvalidateAllObjects<T>()
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>(nameof(InMemoryBlobCache));
         }
 
         lock (_cache)
@@ -384,7 +384,7 @@ public IObservable<Unit> Vacuum()
     {
         if (_disposed)
         {
-            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>("InMemoryBlobCache");
+            return ExceptionHelper.ObservableThrowObjectDisposedException<Unit>(nameof(InMemoryBlobCache));
         }
 
         lock (_cache)

diff --git a/src/Akavache.Core/IsExternalInit.cs b/src/Akavache.Core/IsExternalInit.cs
@@ -8,6 +8,4 @@
 namespace System.Runtime.CompilerServices;
 
 [EditorBrowsable(EditorBrowsableState.Never)]
-internal class IsExternalInit
-{
-}
+internal class IsExternalInit;
diff --git a/src/Akavache.Sqlite3/IsExternalInit.cs b/src/Akavache.Sqlite3/IsExternalInit.cs
@@ -8,6 +8,4 @@
 namespace System.Runtime.CompilerServices;
 
 [EditorBrowsable(EditorBrowsableState.Never)]
-internal class IsExternalInit
-{
-}
+internal class IsExternalInit;
diff --git a/src/Akavache.Sqlite3/Operations/BulkInvalidateByTypeSqliteOperation.cs b/src/Akavache.Sqlite3/Operations/BulkInvalidateByTypeSqliteOperation.cs
@@ -9,6 +9,4 @@ namespace Akavache.Sqlite3;
 
 // NB: This just makes OperationQueue's life easier by giving it a type
 // name.
-internal class BulkInvalidateByTypeSqliteOperation(SQLiteConnection conn) : BulkInvalidateSqliteOperation(conn, true)
-{
-}
+internal class BulkInvalidateByTypeSqliteOperation(SQLiteConnection conn) : BulkInvalidateSqliteOperation(conn, true);
diff --git a/src/Akavache.Sqlite3/Operations/BulkInvalidateSqliteOperation.cs b/src/Akavache.Sqlite3/Operations/BulkInvalidateSqliteOperation.cs
@@ -47,7 +47,7 @@ public BulkInvalidateSqliteOperation(SQLiteConnection conn, bool useTypeInsteadO
 
     public Action PrepareToExecute(IEnumerable<string>? toDelete)
     {
-        var deleteList = (toDelete ?? Array.Empty<string>()).ToList();
+        var deleteList = (toDelete ?? []).ToList();
         if (deleteList.Count == 0)
         {
             return () => { };

diff --git a/src/Akavache.Sqlite3/Operations/BulkSelectByTypeSqliteOperation.cs b/src/Akavache.Sqlite3/Operations/BulkSelectByTypeSqliteOperation.cs
@@ -7,6 +7,4 @@
 
 namespace Akavache.Sqlite3;
 
-internal class BulkSelectByTypeSqliteOperation(SQLiteConnection conn, IScheduler scheduler) : BulkSelectSqliteOperation(conn, true, scheduler)
-{
-}
+internal class BulkSelectByTypeSqliteOperation(SQLiteConnection conn, IScheduler scheduler) : BulkSelectSqliteOperation(conn, true, scheduler);
diff --git a/src/Akavache.Sqlite3/Operations/BulkSelectSqliteOperation.cs b/src/Akavache.Sqlite3/Operations/BulkSelectSqliteOperation.cs
@@ -50,10 +50,10 @@ public BulkSelectSqliteOperation(SQLiteConnection conn, bool useTypeInsteadOfKey
 
     public Func<IEnumerable<CacheElement>> PrepareToExecute(IEnumerable<string>? toSelect)
     {
-        var selectList = (toSelect ?? Array.Empty<string>()).ToList();
+        var selectList = (toSelect ?? []).ToList();
         if (selectList.Count == 0)
         {
-            return () => new List<CacheElement>();
+            return () => [];
         }
 
         var selectOp = _selectOps[selectList.Count - 1];

diff --git a/src/Akavache.Sqlite3/Queues/OperationQueue.cs b/src/Akavache.Sqlite3/Queues/OperationQueue.cs
@@ -372,7 +372,7 @@ public void Dispose()
         _shouldQuit?.Dispose();
     }
 
-    internal List<OperationQueueItem> DumpQueue() => _operationQueue.ToList();
+    internal List<OperationQueueItem> DumpQueue() => [.. _operationQueue];
 
     private static void MarshalCompletion(object completion, Action block, IObservable<Unit> commitResult)
     {

diff --git a/src/Akavache.Sqlite3/Queues/OperationQueueCoalescing.cs b/src/Akavache.Sqlite3/Queues/OperationQueueCoalescing.cs
@@ -32,12 +32,13 @@ internal static List<OperationQueueItem> CoalesceOperations(List<OperationQueueI
         foreach (var v in inputItems)
         {
             var key = GetKeyFromTuple(v) ?? NullKey;
-            if (!groupedOps.ContainsKey(key))
+            if (!groupedOps.TryGetValue(key, out var value))
             {
-                groupedOps.Add(key, new());
+                value = [];
+                groupedOps.Add(key, value);
             }
 
-            var list = groupedOps[key];
+            var list = value;
             list.Add(v);
         }
 
@@ -102,9 +103,9 @@ private static IEnumerable<OperationQueueItem> CoalesceUnrelatedItems(IEnumerabl
         items.GroupBy(x => x.OperationType)
             .SelectMany(group => group.Key switch
             {
-                OperationType.BulkSelectSqliteOperation => new[] { GroupUnrelatedSelects(group) },
-                OperationType.BulkInsertSqliteOperation => new[] { GroupUnrelatedInserts(group) },
-                OperationType.BulkInvalidateSqliteOperation => new[] { GroupUnrelatedDeletes(group) },
+                OperationType.BulkSelectSqliteOperation => [GroupUnrelatedSelects(group)],
+                OperationType.BulkInsertSqliteOperation => [GroupUnrelatedInserts(group)],
+                OperationType.BulkInvalidateSqliteOperation => [GroupUnrelatedDeletes(group)],
                 _ => (IEnumerable<OperationQueueItem>)group
             });
 
@@ -116,7 +117,7 @@ private static IEnumerable<OperationQueueItem> MultipleOpsTurnIntoSingleOp(IEnum
         {
             if (item.OperationType == opTypeToDedup)
             {
-                currentWrites ??= new();
+                currentWrites ??= [];
                 currentWrites.Add(item);
                 continue;
             }
@@ -185,9 +186,7 @@ private static OperationQueueItem GroupUnrelatedSelects(IEnumerable<OperationQue
                 {
                     try
                     {
-                        elementMap[v].OnNext(resultMap.ContainsKey(v)
-                            ? EnumerableEx.Return(resultMap[v])
-                            : Enumerable.Empty<CacheElement>());
+                        elementMap[v].OnNext(resultMap.TryGetValue(v, out var value) ? EnumerableEx.Return(value) : []);
 
                         elementMap[v].OnCompleted();
                     }
@@ -228,7 +227,7 @@ private static OperationQueueItem GroupUnrelatedInserts(IEnumerable<OperationQue
         var elements = operationQueueItems.SelectMany(x =>
         {
             subj.Subscribe(x.CompletionAsUnit);
-            return x.ParametersAsElements ?? Enumerable.Empty<CacheElement>();
+            return x.ParametersAsElements ?? [];
         }).ToList();
 
         return OperationQueueItem.CreateInsert(
@@ -259,7 +258,7 @@ private static OperationQueueItem GroupUnrelatedDeletes(IEnumerable<OperationQue
         var elements = operationQueueItems.SelectMany(x =>
         {
             subj.Subscribe(x.CompletionAsUnit);
-            return x.ParametersAsKeys ?? Enumerable.Empty<string>();
+            return x.ParametersAsKeys ?? [];
         }).ToList();
 
         return OperationQueueItem.CreateInvalidate(
@@ -292,21 +291,17 @@ private static OperationQueueItem GroupUnrelatedDeletes(IEnumerable<OperationQue
 
     private static object CombineSubjectsByOperation(object source, IEnumerable<object>? subjects, OperationType opType)
     {
-        var subjectsList = (subjects ?? Enumerable.Empty<object>()).ToList();
-        switch (opType)
+        var subjectsList = (subjects ?? []).ToList();
+        return opType switch
         {
-            case OperationType.BulkSelectSqliteOperation:
-                return CombineSubjects(
-                    (AsyncSubject<IEnumerable<CacheElement>>)source,
-                    subjectsList.Cast<AsyncSubject<IEnumerable<CacheElement>>>());
-            case OperationType.BulkInsertSqliteOperation:
-            case OperationType.BulkInvalidateSqliteOperation:
-                return CombineSubjects(
-                    (AsyncSubject<Unit>)source,
-                    subjectsList.Cast<AsyncSubject<Unit>>());
-            default:
-                throw new ArgumentException("Invalid operation type", nameof(opType));
-        }
+            OperationType.BulkSelectSqliteOperation => CombineSubjects(
+                                (AsyncSubject<IEnumerable<CacheElement>>)source,
+                                subjectsList.Cast<AsyncSubject<IEnumerable<CacheElement>>>()),
+            OperationType.BulkInsertSqliteOperation or OperationType.BulkInvalidateSqliteOperation => CombineSubjects(
+                                (AsyncSubject<Unit>)source,
+                                subjectsList.Cast<AsyncSubject<Unit>>()),
+            _ => throw new ArgumentException("Invalid operation type", nameof(opType)),
+        };
     }
 
     private static AsyncSubject<T> CombineSubjects<T>(AsyncSubject<T> source, IEnumerable<AsyncSubject<T>> subjs)

diff --git a/src/Akavache.Sqlite3/SqlLiteCache/IObjectWrapper.cs b/src/Akavache.Sqlite3/SqlLiteCache/IObjectWrapper.cs
@@ -8,6 +8,4 @@ namespace Akavache.Sqlite3;
 /// <summary>
 /// A wrapper around a object.
 /// </summary>
-internal interface IObjectWrapper
-{
-}
+internal interface IObjectWrapper;
diff --git a/src/Akavache.Sqlite3/SqlLiteCache/ObjectWrapper.cs b/src/Akavache.Sqlite3/SqlLiteCache/ObjectWrapper.cs
@@ -15,10 +15,7 @@ public ObjectWrapper()
     {
     }
 
-    public ObjectWrapper(T value)
-    {
-        Value = value;
-    }
+    public ObjectWrapper(T value) => Value = value;
 
     public T? Value { get; set; }
 }