on.nemtina/persistence
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

Выделить отдельный Cached репозиторий для систем - источников данных

Browse Source
This commit is contained in:
Roman Efremov 2024-12-13 10:54:47 +05:00
parent 1d40edb535
commit ba75f2c888
4 changed files with 51 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Persistence.Repository/DependencyInjection.cs
View File

@ -34,7 +34,7 @@ public static class DependencyInjection
services.AddTransient<ITimestampedSetRepository, TimestampedSetRepository>();
services.AddTransient<ITechMessagesRepository, TechMessagesRepository>();
services.AddTransient<IParameterRepository, ParameterRepository>();
services.AddTransient<IDataSourceSystemRepository, DataSourceSystemRepository>();
services.AddTransient<IDataSourceSystemRepository, DataSourceSystemCachedRepository>();
return services;
}

34
Persistence.Repository/Repositories/DataSourceSystemCachedRepository.cs Normal file
View File

@ -0,0 +1,34 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Memory;
using Persistence.Models;
namespace Persistence.Repository.Repositories;
public class DataSourceSystemCachedRepository : DataSourceSystemRepository
{
private static readonly string SystemCacheKey = $"{typeof(Database.Entity.DataSourceSystem).FullName}CacheKey";
private readonly IMemoryCache memoryCache;
private const int CacheExpirationInMinutes = 60;
public DataSourceSystemCachedRepository(DbContext db, IMemoryCache memoryCache) : base(db)
{
this.memoryCache = memoryCache;
}
public override async Task Add(DataSourceSystemDto dataSourceSystemDto, CancellationToken token)
{
await base.Add(dataSourceSystemDto, token);
memoryCache.Remove(SystemCacheKey);
}
public override async Task<IEnumerable<DataSourceSystemDto>> Get(CancellationToken token)
{
var systems = await memoryCache.GetOrCreateAsync(SystemCacheKey, async f =>
{
var dtos = await base.Get(token);
return dtos;
});
return systems ?? [];
}
}

29
Persistence.Repository/Repositories/DataSourceSystemRepository.cs
View File

@ -14,40 +14,27 @@ using Persistence.Repositories;
namespace Persistence.Repository.Repositories;
public class DataSourceSystemRepository : IDataSourceSystemRepository
{
private static readonly string SystemCacheKey = $"{typeof(Database.Entity.DataSourceSystem).FullName}CacheKey";
private DbContext db;
private readonly IMemoryCache memoryCache;
private const int CacheExpirationInMinutes = 60;
public DataSourceSystemRepository(DbContext db, IMemoryCache memoryCache)
protected DbContext db;
public DataSourceSystemRepository(DbContext db)
{
this.db = db;
this.memoryCache = memoryCache;
}
protected virtual IQueryable<DataSourceSystem> GetQueryReadOnly() => db.Set<DataSourceSystem>();
public async Task Add(DataSourceSystemDto dataSourceSystemDto, CancellationToken token)
public virtual async Task Add(DataSourceSystemDto dataSourceSystemDto, CancellationToken token)
{
var entity = dataSourceSystemDto.Adapt<DataSourceSystem>();
await db.Set<DataSourceSystem>().AddAsync(entity);
await db.SaveChangesAsync(token);
memoryCache.Remove(SystemCacheKey);
}
public async Task<IEnumerable<DataSourceSystemDto>> Get(CancellationToken token)
public virtual async Task<IEnumerable<DataSourceSystemDto>> Get(CancellationToken token)
{
var systems = await memoryCache.GetOrCreateAsync(SystemCacheKey, async f =>
{
f.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(CacheExpirationInMinutes);
var query = GetQueryReadOnly();
var entities = await query.ToListAsync(token);
var dtos = entities.Select(e => e.Adapt<DataSourceSystemDto>());
var query = GetQueryReadOnly();
var entities = await query.ToListAsync(token);
var dtos = entities.Select(e => e.Adapt<DataSourceSystemDto>());
return dtos;
});
return systems ?? [];
return dtos;
}
}

33
Persistence.Repository/Repositories/TechMessagesRepository.cs
View File

@ -12,15 +12,13 @@ namespace Persistence.Repository.Repositories
{
public class TechMessagesRepository : ITechMessagesRepository
{
private static readonly string SystemCacheKey = $"{typeof(Database.Entity.DataSourceSystem).FullName}CacheKey";
private const int CacheExpirationInMinutes = 60;
private readonly IMemoryCache memoryCache;
private readonly IDataSourceSystemRepository sourceSystemRepository;
private DbContext db;
public TechMessagesRepository(DbContext db, IMemoryCache memoryCache)
public TechMessagesRepository(DbContext db, IDataSourceSystemRepository sourceSystemRepository)
{
this.memoryCache = memoryCache;
this.db = db;
this.sourceSystemRepository = sourceSystemRepository;
}
protected virtual IQueryable<TechMessage> GetQueryReadOnly() => db.Set<TechMessage>()
@ -116,18 +114,9 @@ namespace Persistence.Repository.Repositories
public async Task<IEnumerable<DataSourceSystemDto>> GetSystems(CancellationToken token)
{
var systems = await memoryCache.GetOrCreateAsync(SystemCacheKey, async f =>
{
f.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(CacheExpirationInMinutes);
var systems = await sourceSystemRepository.Get(token);
var query = db.Set<Database.Entity.DataSourceSystem>();
var entities = await query.ToListAsync(token);
var dtos = entities.Select(e => e.Adapt<Models.DataSourceSystemDto>());
return dtos;
});
return systems ?? [];
return systems ?? [];
}
public async Task<DatesRangeDto> GetDatesRangeAsync(CancellationToken token)
@ -151,7 +140,7 @@ namespace Persistence.Repository.Repositories
private async Task CreateSystemIfNotExist(Guid systemId, CancellationToken token)
{
var systems = await GetSystems(token);
var systems = await sourceSystemRepository.Get(token);
var system = systems?.FirstOrDefault(e => e.SystemId == systemId);
if (system == null)
@ -161,14 +150,8 @@ namespace Persistence.Repository.Repositories
SystemId = systemId,
Name = string.Empty
};
var entity = system.Adapt<DataSourceSystem>();
await db.Set<Database.Entity.DataSourceSystem>().AddAsync(entity);
await db.SaveChangesAsync(token);
memoryCache.Remove(SystemCacheKey);
}
await sourceSystemRepository.Add(system, token);
}
}
}
}