Connected/Connected.Framework
14
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

[WIP] Add debug output of entities

Browse Source
This commit is contained in:
Matija Koželj 2023-01-24 18:51:59 +01:00
parent 9381a4e4c6
commit 018a48dd65
1 changed files with 93 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

184
src/Connected.Entities/Caching/EntityCacheClient.cs
View File

@ -10,118 +10,120 @@ using System.Collections.Immutable;
namespace Connected.Entities.Caching;
public abstract class EntityCacheClient<TEntity, TPrimaryKey> : StatefulCacheClient<TEntity, TPrimaryKey>, IEntityCacheClient<TEntity, TPrimaryKey>
where TEntity : class, IPrimaryKey<TPrimaryKey>, IEntity
where TPrimaryKey : notnull
where TEntity : class, IPrimaryKey<TPrimaryKey>, IEntity
where TPrimaryKey : notnull
{
protected EntityCacheClient(IEntityCacheContext context, string key) : base(context.Cache, key)
{
Context = context;
}
protected EntityCacheClient(IEntityCacheContext context, string key) : base(context.Cache, key)
{
Context = context;
}
private IEntityCacheContext Context { get; }
private IEntityCacheContext Context { get; }
protected override sealed async Task OnInitializing()
{
using var ctx = Context.ContextProvider.Create();
protected override sealed async Task OnInitializing()
{
using var ctx = Context.ContextProvider.Create();
var transaction = ctx.GetService<ITransactionContext?>();
var transaction = ctx.GetService<ITransactionContext?>();
try
{
if (await OnInitializing(ctx) is ImmutableList<TEntity> ds)
{
foreach (var r in ds)
Set(r.Id, r, TimeSpan.Zero);
}
try
{
if (await OnInitializing(ctx) is ImmutableList<TEntity> ds)
{
foreach (var r in ds)
Set(r.Id, r, TimeSpan.Zero);
}
if (transaction is not null)
await transaction.Commit();
}
catch
{
if (transaction is not null)
await transaction.Rollback();
if (transaction is not null)
await transaction.Commit();
}
catch
{
if (transaction is not null)
await transaction.Rollback();
throw;
}
}
throw;
}
}
protected virtual async Task<ImmutableList<TEntity>?> OnInitializing(IContext context)
{
if (context.GetService<IStorageProvider>() is not IStorageProvider db)
return default;
protected virtual async Task<ImmutableList<TEntity>?> OnInitializing(IContext context)
{
if (context.GetService<IStorageProvider>() is not IStorageProvider db)
return default;
return await (from dc in db.Open<TEntity>()
select dc).AsEntities();
}
return await (from dc in db.Open<TEntity>()
select dc).AsEntities();
}
protected override async Task OnInvalidate(TPrimaryKey id)
{
using var ctx = Context.ContextProvider.Create();
var transaction = ctx.GetService<ITransactionContext>();
protected override async Task OnInvalidate(TPrimaryKey id)
{
using var ctx = Context.ContextProvider.Create();
var transaction = ctx.GetService<ITransactionContext>();
try
{
if (OnInvalidating(ctx, id) is TEntity entity && entity is IPrimaryKey<TPrimaryKey> pk)
Set(pk.Id, entity, TimeSpan.Zero);
try
{
if (OnInvalidating(ctx, id) is TEntity entity && entity is IPrimaryKey<TPrimaryKey> pk)
Set(pk.Id, entity, TimeSpan.Zero);
if (transaction is not null)
await transaction.Commit();
}
catch
{
if (transaction is not null)
await transaction.Rollback();
if (transaction is not null)
await transaction.Commit();
}
catch
{
if (transaction is not null)
await transaction.Rollback();
throw;
}
}
throw;
}
}
protected virtual async Task<TEntity?> OnInvalidating(IContext context, TPrimaryKey id)
{
if (context.GetService<IStorageProvider>() is not IStorageProvider provider)
return default;
protected virtual async Task<TEntity?> OnInvalidating(IContext context, TPrimaryKey id)
{
if (context.GetService<IStorageProvider>() is not IStorageProvider provider)
return default;
return await (from dc in provider.Open<TEntity>()
where TypeComparer.Compare(dc.Id, id)
select dc).AsEntity();
}
var entities = provider.Open<TEntity>().AsEntities();
async Task IEntityCacheClient<TEntity, TPrimaryKey>.Refresh(TPrimaryKey id)
{
await Refresh(id);
}
return await (from dc in provider.Open<TEntity>()
where TypeComparer.Compare(dc.Id, id)
select dc).AsEntity();
}
async Task IEntityCacheClient<TEntity, TPrimaryKey>.Remove(TPrimaryKey id)
{
await Remove(id);
}
async Task IEntityCacheClient<TEntity, TPrimaryKey>.Refresh(TPrimaryKey id)
{
await Refresh(id);
}
protected override void Set(TPrimaryKey id, TEntity instance)
{
Set(id, instance, TimeSpan.Zero);
}
async Task IEntityCacheClient<TEntity, TPrimaryKey>.Remove(TPrimaryKey id)
{
await Remove(id);
}
protected override void Set(TPrimaryKey id, TEntity instance, TimeSpan duration)
{
if (instance is IConcurrentEntity<TPrimaryKey> concurrent)
{
if (Get(id) is TEntity existing && existing is IConcurrentEntity<TPrimaryKey> existingConcurrent)
{
lock (existingConcurrent)
{
if (existingConcurrent.Sync != concurrent.Sync)
throw new InvalidOperationException(SR.ErrConcurrent);
protected override void Set(TPrimaryKey id, TEntity instance)
{
Set(id, instance, TimeSpan.Zero);
}
concurrent.GetType().GetProperty(nameof(IConcurrentEntity<TPrimaryKey>.Sync))?.SetValue(concurrent, concurrent.Sync + 1);
protected override void Set(TPrimaryKey id, TEntity instance, TimeSpan duration)
{
if (instance is IConcurrentEntity<TPrimaryKey> concurrent)
{
if (Get(id) is TEntity existing && existing is IConcurrentEntity<TPrimaryKey> existingConcurrent)
{
lock (existingConcurrent)
{
if (existingConcurrent.Sync != concurrent.Sync)
throw new InvalidOperationException(SR.ErrConcurrent);
Set(id, instance, duration);
concurrent.GetType().GetProperty(nameof(IConcurrentEntity<TPrimaryKey>.Sync))?.SetValue(concurrent, concurrent.Sync + 1);
return;
}
}
}
Set(id, instance, duration);
base.Set(id, instance, duration);
}
return;
}
}
}
base.Set(id, instance, duration);
}
}