make cache sinchronized.

AsbCloudInfrastructure/Services/Cache/CacheTable.cs

@@ -31,44 +31,73 @@ namespace AsbCloudInfrastructure.Services.Cache
 
         public TEntity this[int index] { get => cached.ElementAt(index); }
 
-        //public static void Sync(Action)
+        /// <summary>
-
+        /// Runs action like atomic operation.
-        public int Refresh()
+        /// wasFree is action argument indicates that semaphore was free.
+        /// It may be needed to avoid multiple operations like Refresh().
+        /// </summary>
+        /// <param name="action">(wasFree) => {...}</param>
+        /// <returns>false - semaphore.Wait returned by timeout</returns>
+        private static bool Sync(Action<bool> action)
         {
             var wasFree = semaphore.CurrentCount > 0;
             if (!semaphore.Wait(semaphoreTimeout))
-                return 0;
+                return false;
             try
             {
-                if (wasFree)
+                action?.Invoke(wasFree);
+            }
+            catch (Exception ex)
+            {
+                Trace.WriteLine($"{DateTime.Now:yyyy.MM.dd HH:mm:ss:fff} error in CacheTable<{typeof(TEntity).Name}>.Sync()");
+                Trace.WriteLine(ex.Message);
+                Trace.WriteLine(ex.StackTrace);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Runs action like atomic operation.
+        /// wasFree is action argument indicates that semaphore was free.
+        /// It may be needed to avoid multiple operations like Refresh().
+        /// </summary>
+        /// <param name="action">(wasFree) => {...}</param>
+        /// <returns>false - semaphore.Wait returned by timeout</returns>
+        private static async Task<bool> SyncAsync(Func<bool, CancellationToken, Task> task, CancellationToken token = default)
+        {
+            var wasFree = semaphore.CurrentCount > 0;
+            if (!await semaphore.WaitAsync(semaphoreTimeout, token).ConfigureAwait(false))
+                return false;
+            try
+            {
+                await task?.Invoke(wasFree, token);
+            }
+            catch (Exception ex)
+            {
+                Trace.WriteLine($"{DateTime.Now:yyyy.MM.dd HH:mm:ss:fff} error in CacheTable<{typeof(TEntity).Name}>.SyncAsync()");
+                Trace.WriteLine(ex.Message);
+                Trace.WriteLine(ex.StackTrace);
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+            return true;
+        }
+
+        private void InternalRefresh()
         {
             cached.Clear();
             var entities = dbSet.AsNoTracking().ToList();
             cached.AddRange(entities);
             data.refreshDate = DateTime.Now;
         }
-                //else - nothing, it was just updated in another thread
-            }
-            catch (Exception ex)
-            {
-                Trace.WriteLine($"{DateTime.Now:yyyy.MM.dd HH:mm:ss:fff} error in CacheTable<{typeof(TEntity).Name}>.Refresh()");
-                Trace.WriteLine(ex.Message);
-            }
-            finally
-            {
-                semaphore.Release();
-            }
-            return cached.Count;
-        }
 
-        public async Task<int> RefreshAsync(CancellationToken token = default)
+        private async Task InternalRefreshAsync(CancellationToken token = default)
-        {
-            var wasFree = semaphore.CurrentCount > 0;
-            if (!await semaphore.WaitAsync(semaphoreTimeout, token).ConfigureAwait(false))
-                return 0;
-            try
-            {
-                if (wasFree)
         {
             cached.Clear();
             var entities = await context.Set<TEntity>().AsNoTracking()
@@ -76,17 +105,22 @@ namespace AsbCloudInfrastructure.Services.Cache
             cached.AddRange(entities);
             data.refreshDate = DateTime.Now;            
         }
-                //else - nothing, it was just updated in another thread
+
-            }
+        public int Refresh()
-            catch (Exception ex)
         {
-                Trace.WriteLine($"{DateTime.Now:yyyy.MM.dd HH:mm:ss:fff} error in CacheTable<{typeof(TEntity).Name}>.Refresh()");
+            Sync((wasFree) => {
-                Trace.WriteLine(ex.Message);
+                if (wasFree)
+                    InternalRefresh();
+                });
+            return cached.Count;
         }
-            finally
+
+        public async Task<int> RefreshAsync(CancellationToken token = default)
         {
-                semaphore.Release();
+            await SyncAsync(async (wasFree, token) => {
-            }
+                if (wasFree)
+                    await InternalRefreshAsync(token).ConfigureAwait(false);
+            }, token).ConfigureAwait(false);
             return cached.Count;
         }
 
@@ -96,6 +130,27 @@ namespace AsbCloudInfrastructure.Services.Cache
         public async Task<bool> ContainsAsync(Func<TEntity, bool> predicate, CancellationToken token = default)
             => await FirstOrDefaultAsync(predicate, token) != default;
 
+        public TEntity GetOrCreate(Func<TEntity, bool> predicate, Func<TEntity> makeNew)
+        {
+            TEntity result = default;
+            Sync(wasFree => {
+                result = cached.FirstOrDefault(predicate);
+                if (result != default)
+                    return;
+
+                InternalRefresh();                
+                result = cached.FirstOrDefault(predicate);
+                if (result != default)
+                    return;
+
+                var entry = dbSet.Add(makeNew());
+                context.SaveChanges();
+                InternalRefresh();
+                result = entry.Entity;                
+            });
+            return result;
+        }
+
         public TEntity FirstOrDefault()
         {
             var result = cached.FirstOrDefault();
@@ -114,7 +169,6 @@ namespace AsbCloudInfrastructure.Services.Cache
 
             await RefreshAsync(token);
             return cached.FirstOrDefault();            
-            
         }
 
         public TEntity FirstOrDefault(Func<TEntity, bool> predicate)
@@ -152,6 +206,9 @@ namespace AsbCloudInfrastructure.Services.Cache
             return result;
         }
 
+        public Task<IEnumerable<TEntity>> WhereAsync(CancellationToken token = default) =>
+            WhereAsync(default, token);
+
         public async Task<IEnumerable<TEntity>> WhereAsync(Func<TEntity, bool> predicate = default,
             CancellationToken token = default)
         {
@@ -168,109 +225,129 @@ namespace AsbCloudInfrastructure.Services.Cache
             return result;
         }
 
-        public TEntity Upsert(TEntity entity)
+        public void Upsert(TEntity entity)
+        {
+            if (entity == default)
+                return;
+            Sync((wasFree) =>
             {
-            Microsoft.EntityFrameworkCore.ChangeTracking.EntityEntry<TEntity> updated;
                 if (dbSet.Contains(entity))
-                updated = dbSet.Update(entity);
+                    dbSet.Update(entity);
                 else
-                updated = dbSet.Add(entity);
+                    dbSet.Add(entity);
                 context.SaveChanges();
-            Refresh();
+                InternalRefresh();
-            return updated.Entity;
+            });                
         }
 
-        public async Task<TEntity> UpsertAsync(TEntity entity, CancellationToken token = default)
+        public Task UpsertAsync(TEntity entity, CancellationToken token = default)
-        {
+        => SyncAsync(async (wasFree, token) => {
-            Microsoft.EntityFrameworkCore.ChangeTracking.EntityEntry<TEntity> updated;
                 if (dbSet.Contains(entity))
-                updated = dbSet.Update(entity);
+                    dbSet.Update(entity);
                 else
-                updated = dbSet.Add(entity);
+                    dbSet.Add(entity);
                 await context.SaveChangesAsync(token).ConfigureAwait(false);
-            await RefreshAsync(token).ConfigureAwait(false);
+                await InternalRefreshAsync(token).ConfigureAwait(false);
-            return updated.Entity;
+            }, token);
-        }
 
-        public IEnumerable<TEntity> Upsert(IEnumerable<TEntity> entities)
+        public void Upsert(IEnumerable<TEntity> entities)
+        {
+            if (!entities.Any())
+                return;
+
+            Sync((wasFree) =>
             {
-            var upsertedEntries = new List<TEntity>(entities.Count());
                 foreach (var entity in entities)
                 {
-                Microsoft.EntityFrameworkCore.ChangeTracking.EntityEntry<TEntity> updated;
                     if (dbSet.Contains(entity)) // TODO: это очень ммедленно
-                    updated = dbSet.Update(entity);
+                        dbSet.Update(entity);
                     else
-                    updated = dbSet.Add(entity);
+                        dbSet.Add(entity);                 
-                upsertedEntries.Add(updated.Entity);
                 }
                 context.SaveChanges();
-            Refresh();
+                InternalRefresh();
-            return upsertedEntries;
+            });
         }
 
-        public async Task<IEnumerable<TEntity>> UpsertAsync(IEnumerable<TEntity> entities, CancellationToken token = default)
+        public async Task UpsertAsync(IEnumerable<TEntity> entities, CancellationToken token = default)
         {
+            if (!entities.Any())
+                return;            
+
+            await SyncAsync(async (wasFree, token) => {
                 var upsertedEntries = new List<TEntity>(entities.Count());
                 foreach (var entity in entities)
                 {
-                Microsoft.EntityFrameworkCore.ChangeTracking.EntityEntry<TEntity> updated;
                     if (dbSet.Contains(entity))
-                    updated = dbSet.Update(entity);
+                        dbSet.Update(entity);
                     else
-                    updated = dbSet.Add(entity);
+                        dbSet.Add(entity);
-                upsertedEntries.Add(updated.Entity);
                 }
                 await context.SaveChangesAsync(token).ConfigureAwait(false);
-            await RefreshAsync(token).ConfigureAwait(false);
+                await InternalRefreshAsync(token).ConfigureAwait(false);
-            return upsertedEntries;
+            }, token);
         }
 
         public void Remove(Func<TEntity, bool> predicate)
+        => Sync(_ =>
             {
                 dbSet.RemoveRange(dbSet.Where(predicate));
                 context.SaveChanges();
-            Refresh();
+                InternalRefresh();
-            return;
+            });
-        }
         
-        public async Task RemoveAsync(Func<TEntity, bool> predicate, CancellationToken token = default)
+        public Task RemoveAsync(Func<TEntity, bool> predicate, CancellationToken token = default)
-        {
+            => SyncAsync(async (wasFree, token) => {
                 dbSet.RemoveRange(dbSet.Where(predicate));
                 await context.SaveChangesAsync(token).ConfigureAwait(false);
-            await RefreshAsync(token).ConfigureAwait(false);
+                await InternalRefreshAsync(token).ConfigureAwait(false);
-            return;
+            }, token);
-        }
 
         public TEntity Insert(TEntity entity)
+        {
+            TEntity result = default;
+            Sync(_ =>
             {
                 var entry = dbSet.Add(entity);
                 context.SaveChanges();
-            Refresh();
+                InternalRefresh();
-            return entry.Entity;
+                result = entry.Entity;
+            });
+            return result;
         }
 
         public async Task<TEntity> InsertAsync(TEntity entity, CancellationToken token = default)
+        {
+            TEntity result = default;
+            await SyncAsync(async (wasFree, token) =>
             {
                 var entry = dbSet.Add(entity);
                 await context.SaveChangesAsync(token).ConfigureAwait(false);
-            await RefreshAsync(token).ConfigureAwait(false);
+                await InternalRefreshAsync(token).ConfigureAwait(false);
-            return entry.Entity;
+                result = entry.Entity;
+            }, token);
+            return result;
         }
 
         public int Insert(IEnumerable<TEntity> newEntities)
         {
+            int result = 0;
+            Sync(_ => {
                 dbSet.AddRange(newEntities);
-            var result = context.SaveChanges();
+                result = context.SaveChanges();
-            Refresh();
+                InternalRefresh();
+            });            
             return result;
         }
 
         public async Task<int> InsertAsync(IEnumerable<TEntity> newEntities, CancellationToken token = default)
         {
+            int result = 0;
+            await SyncAsync(async (wasFree, token) => {
                 dbSet.AddRange(newEntities);
-            var result = await context.SaveChangesAsync(token).ConfigureAwait(false);
+                result = await context.SaveChangesAsync(token).ConfigureAwait(false);
                 await RefreshAsync(token).ConfigureAwait(false);
+            }, token);
             return result;
         }