async Task <IQueryableCollection <TResult> > IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, ICollection <TResult> > > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
string propertyName = GetPropertyName(expression);
var entry = InnerContext.Entry((object)entity);
var reference = entry.Collection(propertyName);
var property = entry.Metadata.FindNavigation(propertyName);
var context = this.GetWrappedContext <TResult>();
if (entry.State == EntityState.Detached)
{
entry.State = EntityState.Unchanged;
}
var queryable = (IQueryable <TResult>)reference.Query();
var count = await queryable.CountAsync();
return(new ComBoostEntityCollection <TResult>(entry, context, property, queryable, count));
}
async Task <TResult> IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, TResult> > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
string propertyName = GetPropertyName(expression);
var entry = InnerContext.Entry((object)entity);
var reference = entry.Reference(propertyName);
if (!reference.IsLoaded)
{
if (entry.State == EntityState.Detached)
{
entry.State = EntityState.Unchanged;
}
await reference.LoadAsync();
}
TResult result = expression.Compile()(entity);
return(result);
}
async Task <TResult> IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, TResult> > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
string propertyName = GetPropertyName(expression);
var entry = InnerContext.ChangeTracker.Entries <TSource>().FirstOrDefault(t => t.Entity.Index.Equals(entity.Index));
if (entry != null && entry.Entity != entity)
{
entry.CurrentValues.SetValues(entity);
}
else
{
entry = InnerContext.Entry(entity);
}
var reference = entry.Reference(propertyName);
if (!reference.IsLoaded)
{
if (entry.State == EntityState.Detached)
{
entry.State = EntityState.Unchanged;
}
await reference.LoadAsync();
}
return((TResult)reference.CurrentValue);
}
Task <TResult> IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, TResult> > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
TResult result = expression.Compile()(entity);
if (result != null)
{
return(Task.FromResult(result));
}
string propertyName = GetPropertyName(expression);
var entry = InnerContext.Entry((object)entity);
var property = entry.Metadata.FindNavigation(propertyName).ForeignKey.Properties[0];
var infrastructure = entry.GetInfrastructure();
var key = infrastructure.GetCurrentValue(property);
if (key == null)
{
return(null);
}
var context = this.GetWrappedContext <TResult>();
return(context.GetAsync(key));
}
async Task <TResult> IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, TResult> > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
//TResult result = expression.Compile()(entity);
//if (result != null)
// return result;
string propertyName = GetPropertyName(expression);
var entry = InnerContext.Entry((object)entity);
var property = entry.Reference(propertyName);
if (property.IsLoaded)
{
return((TResult)property.CurrentValue);
}
//var infrastructure = entry.GetInfrastructure();
await property.LoadAsync();
return((TResult)property.CurrentValue);
}
public IQueryable <T> Include <TProperty>(IQueryable <T> query, Expression <Func <T, TProperty> > expression)
{
ExpressionWrapper <T, M> wrapper = new ExpressionWrapper <T, M>();
LambdaExpression newExpression = (LambdaExpression)wrapper.Visit(expression);
var propertyType = newExpression.Type.GetGenericArguments()[1];
var queryable = query.Unwrap <T, M>();
queryable = (IQueryable <M>)InnerContext.GetType().GetMethod("Include").MakeGenericMethod(propertyType).Invoke(InnerContext, new object[] { queryable, newExpression });
return(queryable.Wrap <T, M>());
}
public virtual void SaveChanges()
{
if (_saveCalled || _rollBackCalled)
{
throw new InvalidOperationException("This Unit-Of-Work has been already completed.");
}
_saveCalled = true;
InnerContext.SaveChanges(); // TODO: add asynchronous operations as part of the exercise ;-)
}
public override TiffPixelBufferWriter <TPixel> GetWriter <TPixel>()
{
TiffPixelBufferWriter <TPixel> writer = InnerContext.GetWriter <TPixel>();
if (_isFlipOrOrientation)
{
return(new TiffOrientedPixelBufferWriter <TPixel>(writer, _flipLeftRigt, _flipTopBottom).AsPixelBufferWriter());
}
return(new TiffFlippedPixelBufferWriter <TPixel>(writer, _flipLeftRigt, _flipTopBottom).AsPixelBufferWriter());
}
/// <summary>
/// Gets whether a given Variable exists in this Context.
/// </summary>
/// <param name="var">Variable Node.</param>
/// <returns></returns>
public bool IsVariable(INode var)
{
if (InnerContext == null)
{
return(_vars.Contains(var));
}
else
{
return(_vars.Contains(var) || InnerContext.IsVariable(var));
}
}
public IEntityContext <T> GetContext <T>() where T : class, IEntity, new()
{
if (_CachedEntityContext.ContainsKey(typeof(T)))
{
return((EntityContext <T>)_CachedEntityContext[typeof(T)]);
}
var context = new EntityContext <T>(this, InnerContext.Set <T>());
_CachedEntityContext.Add(typeof(T), context);
return(context);
}
static List <Action> CreateCountingActions()
{
List <Action> actions = new List <Action>();
OuterContext outerContext = new OuterContext();
outerContext.outerCounter = 0;
for (int i = 0; i < 2; i++)
{
InnerContext innerContext = new InnerContext();
innerContext.outerContext = outerContext;
innerContext.innerCounter = 0;
Action action = innerContext.Method;
actions.Add(action);
}
return(actions);
}
async Task <IQueryableCollection <TResult> > IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, ICollection <TResult> > > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
string propertyName = GetPropertyName(expression);
var entry = InnerContext.Entry((object)entity);
var property = entry.Collection(propertyName);
IQueryable <TResult> queryable = (IQueryable <TResult>)property.Query();
var context = this.GetWrappedContext <TResult>();
var count = await context.CountAsync(queryable);
return(new ComBoostEntityCollection <TResult>(entry, context, property, queryable, count));
}
async Task <TResult> IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, TResult> > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
string propertyName = GetPropertyName(expression);
var entry = InnerContext.Entry((object)entity);
var property = entry.Reference(propertyName);
if (!property.IsLoaded)
{
await property.LoadAsync();
}
return((TResult)property.CurrentValue);
}
async Task <IQueryableCollection <TResult> > IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, ICollection <TResult> > > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
string propertyName = GetPropertyName(expression);
var entry = InnerContext.Entry((object)entity);
var property = entry.Metadata.FindNavigation(propertyName);
var inverseProperty = property.FindInverse();
var parameterExpression = Expression.Parameter(typeof(TResult));
Expression propertyExpression = Expression.Property(parameterExpression, inverseProperty.Name);
if (inverseProperty.IsCollection())
{
var whereP = Expression.Parameter(typeof(TSource));
var equalE = Expression.Equal(Expression.Property(whereP, "Index"), Expression.Constant(entity.Index));
var lambdaE = Expression.Lambda <Func <TSource, bool> >(equalE, whereP);
propertyExpression = Expression.Call(typeof(Queryable).GetMethod("Any", new Type[] { typeof(IQueryable <TSource>), typeof(Expression <Func <TSource, bool> >) }), propertyExpression, lambdaE);
}
else
{
propertyExpression = Expression.Property(propertyExpression, "Index");
}
var equalExpression = Expression.Equal(propertyExpression, Expression.Constant(entity.Index));
var lambdaExpression = Expression.Lambda <Func <TResult, bool> >(equalExpression, parameterExpression);
//entry.GetInfrastructure().AddToCollectionSnapshot()
var context = this.GetWrappedContext <TResult>();
var queryable = context.Query().Where(lambdaExpression);
var count = await context.CountAsync(queryable);
return(new ComBoostEntityCollection <TResult>(entry, context, property, queryable, count));
}
async Task <IQueryableCollection <TResult> > IDatabaseContext.LoadAsync <TSource, TResult>(TSource entity, Expression <Func <TSource, ICollection <TResult> > > expression)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
string propertyName = GetPropertyName(expression);
var entry = InnerContext.ChangeTracker.Entries <TSource>().FirstOrDefault(t => t.Entity.Index.Equals(entity.Index));
if (entry != null && entry.Entity != entity)
{
entry.CurrentValues.SetValues(entity);
}
else
{
entry = InnerContext.Entry(entity);
}
var reference = entry.Collection(propertyName);
var property = entry.Metadata.FindNavigation(propertyName);
var context = this.GetWrappedContext <TResult>();
if (entry.State == EntityState.Detached)
{
entry.State = EntityState.Unchanged;
}
var queryable = (IQueryable <TResult>)reference.Query();
var count = await queryable.CountAsync();
if (!TrackEntity)
{
queryable = queryable.AsNoTracking();
}
return(new ComBoostEntityCollection <TResult>(entry, context, property, queryable, count));
}
public async Task <T> GetAsync(object key)
{
return((M)await InnerContext.GetAsync(key));
}
public Task <int> SaveAsync()
{
return(InnerContext.SaveChangesAsync());
}
public Task ReloadAsync(T item)
{
return(InnerContext.ReloadAsync((M)item));
}
public void Add(T item)
{
InnerContext.Add((M)item);
}
public override TiffPixelBufferWriter <TPixel> GetWriter <TPixel>()
{
return(InnerContext.GetWriter <TPixel>().Crop(CropOffset, ReadSize));
}
public void RemoveRange(IEnumerable <T> items)
{
InnerContext.RemoveRange(items.Cast <M>());
}
public Task <int> CountAsync(IQueryable <T> query)
{
return(InnerContext.CountAsync(query.Unwrap <T, M>()));
}
public T Create()
{
return(InnerContext.Create());
}
public async Task <T> FirstAsync(IQueryable <T> query)
{
return(await InnerContext.FirstAsync(query.Unwrap <T, M>()));
}
public async Task <List <T> > ToListAsync(IQueryable <T> query)
{
return((await InnerContext.ToListAsync(query.Unwrap <T, M>())).Cast <T>().ToList());
}
public IQueryable <T> Query()
{
return(InnerContext.Query().Wrap <T, M>());
}
public async Task <T> SingleOrDefaultAsync(IQueryable <T> query)
{
return(await InnerContext.SingleOrDefaultAsync(query.Unwrap <T, M>()));
}
public void AddRange(IEnumerable <T> items)
{
InnerContext.AddRange(items.Cast <M>());
}
public async Task <T[]> ToArrayAsync(IQueryable <T> query)
{
return((await InnerContext.ToArrayAsync(query.Unwrap <T, M>())).Cast <T>().ToArray());
}
public void Remove(T item)
{
InnerContext.Remove((M)item);
}
