private void LoadItems()
{
var descriptors = albumModel.AlbumCollectionDescriptors;
if (!descriptors.Any())
{
return;
}
AttachmentType attachType = descriptors[0].ChildAttachmentType;
using (var context = contextFactory.CreateContext <TAttachmentModel>())
{
var albumItems =
context.Objects
.AsEnumerable()
.Where(attachment =>
{
return(albumModel.AlbumCollectionDescriptors.Any(descriptor => descriptor.ChildAttachmentId == attachment.Id));
});
allDecorators.AddRange(albumItems.Select(decoratorFactory));
predicatedDecorators.AddRange(predicate == null ? allDecorators : allDecorators.Where(predicate));
}
}
public void Create(PerfomanceDto request)
{
using (var context = mDbContextFactory.CreateContext())
{
var perfomance = new Perfomance
{
Id = Guid.NewGuid(),
Name = request.Name,
Description = request.Description
};
if (request.PlayPeriods != null && request.PlayPeriods.Any())
{
foreach (var playPeriodDto in request.PlayPeriods)
{
var playPeriod = new PlayPeriod
{
Id = Guid.NewGuid(),
StartDate = playPeriodDto.StartDate,
EndDate = playPeriodDto.EndDate,
TicketsCapacity = playPeriodDto.TicketsCapacity
};
perfomance.PlayPeriods.Add(playPeriod);
}
}
context.Set <Perfomance>().Add(perfomance);
context.SaveChanges();
}
}
public void TestRepository()
{
AdhesiveFramework.Start();
Customer c2 = null;
IDbContextFactory dbContextFactory = LocalServiceLocator.GetService <IDbContextFactory>();
IRepositoryFactory repositoryFactory = LocalServiceLocator.GetService <IRepositoryFactory>();
using (IAdhesiveUnitOfwork adhesiveUnitOfWork = dbContextFactory.CreateContext <AdhesiveUnitOfwork>())
{
ICustomerRepository customerRepository = repositoryFactory.CreateRepository <Customer, CustomerRepository>(adhesiveUnitOfWork);
var c1 = new Customer {
FirstName = "James", LastName = "Chan"
};
customerRepository.Add(c1);
customerRepository.UnitOfWork.Commit();
c2 = customerRepository.Get(c1.Id);
Assert.IsNotNull(c2);
}
using (IAdhesiveUnitOfwork adhesiveUnitOfWork = dbContextFactory.CreateContext <AdhesiveUnitOfwork>())
{
ICustomerRepository customerRepository = repositoryFactory.CreateRepository <Customer, CustomerRepository>(adhesiveUnitOfWork);
customerRepository.TrackItem(c2);
c2.FirstName = "James";
customerRepository.UnitOfWork.Commit();
}
AdhesiveFramework.End();
}
public bool IsUpdateRequired()
{
using (var context = _factory.CreateContext())
{
return(!context.PriceModels.Any());
}
}
private async Task <PriceModel[]> GetPriceModels(DateTime start, DateTime end,
string instrumentOwner, string instrument, string portfolio)
{
using (var context = _dbContextFactory.CreateContext())
{
var repository = new DbRepository <PriceModel>(context);
var isInstrumentOwnerEmpty = string.IsNullOrEmpty(instrumentOwner);
var isInstrumentEmpty = string.IsNullOrEmpty(instrument);
var isPortfolioEmpty = string.IsNullOrEmpty(portfolio);
var priceModels = await repository.FindAsync(x =>
(isInstrumentOwnerEmpty || x.InstrumentOwner.Name == instrumentOwner) &&
(isInstrumentEmpty || x.Instrument.Name == instrument) &&
(isPortfolioEmpty || x.Portfolio.Name == portfolio) &&
x.Date >= start && x.Date < end);
if (!priceModels.Any())
{
throw new PriceModelAbsentException(start);
}
return(priceModels);
}
}
public void TestStorageContext()
{
AdhesiveFramework.Start();
IDbContextFactory dbContextFactory = LocalServiceLocator.GetService <IDbContextFactory>();
//string customerId = null;
//using (CustomerDbContext context = dbContextFactory.CreateContext<CustomerDbContext>())
//{
// context.Customers.Each(e => context.Customers.Remove(e));
// context.SaveChanges();
//}
using (CustomerDbContext context = dbContextFactory.CreateContext <CustomerDbContext>())
{
Customer c = new Customer();
c.FirstName = "James";
c.LastName = "Chan";
context.Customers.Add(c);
context.SaveChanges();
//customerId = c.Id;
}
//using (CustomerDbContext context = dbContextFactory.CreateContext<CustomerDbContext>())
//{
// Customer c = context.Customers.Find(customerId);
// if (c != null)
// {
// c.FirstName = "Alex";
// context.SaveChanges();
// }
//}
AdhesiveFramework.End();
}
public void DoWork()
{
using (IocDbContext db = _dbContextFactory.CreateContext())
{
// use EF here...
}
}
private void Init()
{
globalInterceptors = interceptorsResolver.GetGlobalInterceptors();
contextWrapper = factory.CreateContext();
contextWrapper.EntityLoaded += OnEntityLoaded;
}
public Task <Result <bool, Exception> > HandleAsync(GetSchoolInitializationStatusQuery parameters, CancellationToken cancellationToken)
{
return(Result.TryAsync(async() =>
{
using var context = _dbContextFactory.CreateContext();
return await context.Courses.AnyAsync(cancellationToken);
}));
}
public Task <Result <Unit, Exception> > InitializeAsync(CancellationToken cancellationToken = default)
{
return(Result.TryAsync(async() =>
{
using var context = _dbContextFactory.CreateContext();
await context.Database.MigrateAsync(cancellationToken);
}));
}
public void SaveNewSqueedBrew(string brewName)
{
using var context = _contextFactory.CreateContext();
/*
* context.SqueedBrews.Add(new SqueedBrew { Name: brewName });
* context.SaveChanges();
*/
}
private EntityContainer GetEntityContainer()
{
DbContext dbContext = dbContextFactory.CreateContext("Default" /* TODO */); //TODO: dispose or not?
ObjectContext objectContext = ((IObjectContextAdapter)dbContext).ObjectContext;
EntityContainerMapping containerMapping = objectContext.MetadataWorkspace
.GetItem <EntityContainerMapping>(objectContext.DefaultContainerName, DataSpace.CSSpace);
EntityContainer container = containerMapping.StoreEntityContainer;
return(container);
}
public Task <Result <Unit, Exception> > HandleAsync(SaveEnrollmentDataCommand parameters, CancellationToken cancellationToken)
{
return(Result.TryAsync(async() =>
{
using (var context = _contextFactory.CreateContext())
{
context.Enrollments.AddRange(parameters.EnrollmentCollection.Select(x => x.ToEnrollmentRecord()).ToArray());
await context.SaveChangesAsync(cancellationToken);
}
}));
}
public PatternRepositorieTests()
{
var dbContext = MockApplicationDbContext();
_patternRepositoryFactory = Substitute.For <IDbContextFactory>();
_patternRepositoryFactory.CreateContext().Returns(dbContext);
var builder = new ContainerBuilder();
builder.RegisterInstance(_patternRepositoryFactory).As <IDbContextFactory>();
Di.DiContainer.Container = builder.Build();
_patternRepository = new PatternRepositorie();
}
public DbContext GetDbContext(string schemaSpace)
{
lock (this)
{
DbContext dbContext;
if (dbContexts.TryGetValue(schemaSpace, out dbContext))
{
return(dbContext);
}
dbContext = dbContextFactory.CreateContext(schemaSpace);
dbContexts.Add(schemaSpace, dbContext);
requestDbContextCache.AddDbContext(dbContext);
return(dbContext);
}
}
public ICollection <TicketDto> GetPlayperiodsTickets(ICollection <PlayPeriodDto> playPeriodDtos)
{
using (var context = mDbContextFactory.CreateContext())
{
var playPeriodIds = playPeriodDtos.Select(x => x.Id);
var tickets =
context.Set <PlayPeriod>()
.Where(x => playPeriodIds.Contains(x.Id))
.SelectMany(x => x.Tickets)
.Select(x => new TicketDto
{
Id = x.Id,
Email = x.UserEmail,
TicketStartDate = x.PlayPeriod.StartDate,
TicketEndDate = x.PlayPeriod.EndDate
});
return(tickets.ToList());
}
}
public void Create(PlayPeriodDto request, string userEmail)
{
using (var context = mDbContextFactory.CreateContext())
{
var currentPlayPeriod = context.Set <PlayPeriod>().FirstOrDefault(x => x.Id == request.Id);
if (currentPlayPeriod == null)
{
throw new ApplicationException("Период не найден");
}
currentPlayPeriod.TicketsCapacity--;
var ticket = new Ticket
{
Id = Guid.NewGuid(),
UserEmail = userEmail
};
currentPlayPeriod.Tickets.Add(ticket);
context.SaveChanges();
}
}
public async Task <WalletReportLine[]> GenerateReportAsync(string accountId, CancellationToken ct)
{
using TransactionScope tran = Tran.BeginScope(IsolationLevel.ReadCommitted);
using AppDbContext ctx = _dbContextFactory.CreateContext();
_logger.LogDebug("Trying calculate balance");
WalletReportLine[] income = await ctx.Set <PaymentEntity>()
.Where(p => p.To == accountId && p.TransactionSuccessful)
.GroupBy(g => g.From)
.Select(s => new WalletReportLine()
{
AccountId = s.Key, Amount = s.Sum(r => r.Amount)
})
.ToArrayAsync(ct);
WalletReportLine[] outcome = await ctx.Set <PaymentEntity>()
.Where(p => p.From == accountId && p.TransactionSuccessful)
.GroupBy(g => g.To)
.Select(s => new WalletReportLine()
{
AccountId = s.Key, Amount = -s.Sum(r => r.Amount)
})
.ToArrayAsync(ct);
WalletReportLine[] report =
income.Union(outcome)
.GroupBy(g => g.AccountId)
.Select(s => new WalletReportLine()
{
AccountId = s.Key, Amount = s.Sum(r => r.Amount)
})
.ToArray();
_logger.LogDebug("The balance is calculated");
tran.Complete();
return(report);
}
private async Task SavePaymentsAsync(PaymentEntity[] payments, CancellationToken ct)
{
if (!payments.Any())
{
return;
}
using TransactionScope tran = Tran.BeginScope(IsolationLevel.Serializable);
using AppDbContext ctx = _dbContextFactory.CreateContext();
IEnumerable <long> range = payments.Select(p => p.Id);
_logger.LogDebug("Trying to fetch existed payments in range {0}", range);
ctx.SelectWithUpdLock = true;
long[] existingPayments = await ctx.Set <PaymentEntity>()
.Where(p => range.Contains(p.Id))
.AsNoTracking()
.Select(p => p.Id)
.ToArrayAsync(ct);
_logger.LogDebug("{0} payments found", existingPayments.Length);
PaymentEntity[] paymentsToSave =
payments.Where(p => !existingPayments
.Contains(p.Id)).ToArray();
_logger.LogDebug("Trying to save new payments {0}", (object)paymentsToSave);
ctx.Set <PaymentEntity>().AddRange(paymentsToSave);
await ctx.SaveChangesAsync(ct);
tran.Complete();
_logger.LogDebug("{0} new payments successfully saved", paymentsToSave.Count());
}
public void Run()
{
using AppDbContext ctx = _dbContextFactory.CreateContext();
ctx.Database.Migrate();
}
public DbContext(IDbContextFactory dbContextFactory)
{
dbContext = dbContextFactory.CreateContext();
}
public T Find <T>(Guid id, WriteAndReadEnum writeAndRead = WriteAndReadEnum.Read) where T : class
{
_context = _DbContextfactory.CreateContext(writeAndRead);
return(this._context.Set <T>().Find(id));
}
public UnitOfWork(IDbContextFactory dbContextFactory)
{
dbContext = dbContextFactory.CreateContext();
}
public void SaveComplexObjects <TComplexObject>(IEnumerable <TComplexObject> objectsToSave)
where TComplexObject : ComplexDbObject, new()
{
objectsToSave.AssertNotNull(nameof(objectsToSave));
if (!objectsToSave.Any())
{
return;
}
try
{
//var efLogs = new List<string>();
//RemoveCascade<TComplexObject>();
using (var context = contextFactory.CreateContext <TComplexObject>())
{
//complexContext.Database.Log = efLogs.Add;
// для полного удаления сложного объекта нужно приложить к нему названия его дочерних пропертей (которым соответствуют отдельные таблицы)
TComplexObject firstObject = objectsToSave.First();
DbQuery <TComplexObject> allObjectsQuery = IncludeProps(context, firstObject.GetIncludedPropNames());
foreach (string childPropName in firstObject.IncludedChildPropNames)
{
allObjectsQuery.Include(childPropName);
}
//List<TComplexObject> allObjects = allObjectsQuery.ToList();
//complexContext.Objects.RemoveRange(allObjects);
foreach (TComplexObject complexObject in objectsToSave)
{
SetTimestamps(complexObject as AttachmentModelBase);
complexObject.PrepareNavigationProps();
var existingObject = allObjectsQuery.FirstOrDefault(obj => obj.Id == complexObject.Id);
if (existingObject == null)
{
DbEntityEntry <TComplexObject> entry = context.Entry(complexObject);
entry.State = EntityState.Added;
}
else
{
context.Objects.Remove(existingObject);
context.Objects.Add(complexObject);
//existingObject.AcceptProps(complexObject);
//DbEntityEntry<TComplexObject> entry = context.Entry(existingObject);
//existingObject.PrepareNavigationProps();
//entry.State = EntityState.Modified;
}
}
context.SaveChanges();
}
}
catch (Exception ex)
{
if (ex.HResult == -2146233079)
{
// последствие тупого двойного инсерта, который EF пытался задолбить в базу.
// второй инсерт мы игнорили, так что в базе одна запись - всё хорошо
return;
}
throw;
}
}
static void Main(string[] args)
{
AdhesiveFramework.Start();
Console.ReadLine();
IDbContextFactory dbContextFactory = LocalServiceLocator.GetService <IDbContextFactory>();
using (var context = dbContextFactory.CreateContext <AlarmDbContext>())
{
var alarm1 = new AlarmItem
{
AlarmConfigName = "Asdadsad",
AlarmStatus = AlarmStatus.Open,
OpenTime = DateTime.Now,
AlarmTimes = 10,
};
var alarm2 = new AlarmItem
{
AlarmConfigName = "Asdadsad",
AlarmStatus = AlarmStatus.Handling,
HandleTime = DateTime.Now,
OpenTime = DateTime.Now,
AlarmTimes = 10,
};
var alarm3 = new AlarmItem
{
AlarmConfigName = "Asdadsad",
AlarmStatus = AlarmStatus.Closed,
AlarmTimes = 10,
OpenTime = DateTime.Now,
CloseTime = DateTime.Now,
HandleTime = DateTime.Now,
};
var alarmprocess1 = new AlarmProcessItem()
{
AlarmItem = alarm3,
MailComment = "邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息",
MobileComment = "短信消息短信消息短信消息短信消息短信消息短信消息",
AlarmStatus = AlarmStatus.Handling,
ProcessUserName = "******",
ProcessUserRealName = "朱晔",
EventTime = DateTime.Now,
};
var alarmprocess2 = new AlarmProcessItem()
{
AlarmItem = alarm3,
MailComment = "邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息",
MobileComment = "短信消息短信消息短信消息短信消息短信消息短信消息",
AlarmStatus = AlarmStatus.Handling,
ProcessUserName = "******",
ProcessUserRealName = "朱晔",
EventTime = DateTime.Now,
};
var alarmprocess3 = new AlarmProcessItem()
{
AlarmItem = alarm3,
MailComment = "邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息邮件消息",
MobileComment = "短信消息短信消息短信消息短信消息短信消息短信消息",
AlarmStatus = AlarmStatus.Closed,
ProcessUserName = "******",
ProcessUserRealName = "朱晔",
EventTime = DateTime.Now,
};
context.AlarmItems.Add(alarm1);
context.AlarmItems.Add(alarm2);
context.AlarmItems.Add(alarm3);
context.AlarmProcessItems.Add(alarmprocess1);
context.AlarmProcessItems.Add(alarmprocess2);
context.AlarmProcessItems.Add(alarmprocess3);
context.SaveChanges();
}
AdhesiveFramework.End();
}
public ICollection <PerfomanceDto> SelectPagedPerfomances(int pageNumber, int recordsOnPage, DateTime startDate, DateTime endDate, string name)
{
using (var context = mDbContextFactory.CreateContext())
{
var offset = (pageNumber - 1) * recordsOnPage;
var result =
context.Database.SqlQuery <PerfomanceDto>
(
"dbo.SelectPerfomancesPage @offset, @fetch, @startDate, @endDate, @name",
new SqlParameter("offset", offset),
new SqlParameter("fetch", recordsOnPage),
new SqlParameter("startDate", startDate),
new SqlParameter("endDate", endDate),
new SqlParameter("name", name)
)
.ToList();
foreach (var perfomance in result)
{
perfomance.PlayPeriods =
context.Set <PlayPeriod>().AsNoTracking()
.Where(x => x.PerfomanceId == perfomance.Id)
.Select
(
y => new PlayPeriodDto
{
Id = y.Id,
EndDate = y.EndDate,
StartDate = y.StartDate,
PerfomanceId = y.PerfomanceId,
TicketsCapacity = y.TicketsCapacity
}
)
.ToList();
}
//На мой взгляд, лучше сделать так. Либо писать хитровымудренный скрипт для подтягивания связанных сущностей в одном запросе.
//context.Database.Log = msg => Debug.WriteLine(msg);
//var result =
// context.Set<Perfomance>()
// .OrderBy(x => x.Name)
// .Skip(offset)
// .Take(recordsOnPage)
// .Select
// (
// x => new PerfomanceDto
// {
// Id = x.Id,
// Description = x.Description,
// Name = x.Name,
// PlayPeriods =
// x.PlayPeriods
// .Select
// (
// y => new PlayPeriodDto
// {
// Id = y.Id,
// EndDate = y.EndDate,
// StartDate = y.StartDate,
// PerfomanceId = y.PerfomanceId,
// TicketsCapacity = y.TicketsCapacity
// }
// )
// }
// )
// .ToList();
return(result);
}
}
public static TContext CreateRepository <TContext>() where TContext : IDbContext
{
TContext result = context.CreateContext <TContext>();
return(result);
}
