public static string AddComputedToModel(Type modelType, object model, string modelName)
{
var sb = new StringBuilder();
foreach (var property in modelType.GetProperties())
{
if (property.GetCustomAttributes(typeof(ComputedAttribute), false).Any())
{
sb.Append(modelName);
sb.Append('.');
sb.Append(property.Name);
sb.Append(" = ");
sb.Append("ko.computed(function() { try { return ");
sb.Append(ExpressionToString(modelType, DecompileExpressionVisitor.Decompile(Expression.Property(Expression.Constant(model), property))));
sb.Append(string.Format("}} catch(e) {{ return null; }} ;}}, {0});", modelName));
sb.AppendLine();
}
}
foreach (var property in modelType.GetProperties())
{
if (property.PropertyType.IsClass && !typeof(IEnumerable).IsAssignableFrom(property.PropertyType))
{
sb.Append(AddComputedToModel(property.PropertyType, property.GetValue(model, null), modelName + "." + property.Name));
}
}
return(sb.ToString());
}
public static IQueryable <T> Include <T, TEnumerable>(this IQueryable <T> queryable, Expression <Func <T, IEnumerable <TEnumerable> > > path)
{
var body = path.Body;
var member = (PropertyInfo)((MemberExpression)body).Member;
var decompiled = DecompileExpressionVisitor.Decompile(body) as MethodCallExpression;
var converted = Expression.Convert(decompiled.Arguments[0], typeof(ICollection <TEnumerable>));
var collectionExpression = Expression.Lambda <Func <T, ICollection <TEnumerable> > >(converted, path.Parameters);
return(QueryableExtensions.Include(queryable, collectionExpression));
}
public Task <TResult> ExecuteAsync <TResult>(Expression expression, CancellationToken cancellationToken)
{
if (!(inner is IAsyncQueryProvider asyncProvider))
{
throw new InvalidOperationException("The source IQueryProvider doesn't implement IDbAsyncQueryProvider.");
}
var decompiled = DecompileExpressionVisitor.Decompile(expression);
return(asyncProvider.ExecuteAsync <TResult>(decompiled, cancellationToken));
}
public Task <object> ExecuteAsync(Expression expression, CancellationToken cancellationToken)
{
IDbAsyncQueryProvider asyncProvider = inner as IDbAsyncQueryProvider;
if (asyncProvider == null)
{
throw new InvalidOperationException("The source IQueryProvider doesn't implement IDbAsyncQueryProvider.");
}
var decompiled = DecompileExpressionVisitor.Decompile(expression);
return(asyncProvider.ExecuteAsync(decompiled, cancellationToken));
}
public static ManyNavigationPropertyConfiguration <T, TTarget> HasMany <T, TTarget>(
this EntityTypeConfiguration <T> source,
Expression <Func <T, IEnumerable <TTarget> > > navigationPropertyExpression)
where T : class
where TTarget : class
{
var body = navigationPropertyExpression.Body;
var member = (PropertyInfo)((MemberExpression)body).Member;
var decompiled = DecompileExpressionVisitor.Decompile(body) as MethodCallExpression;
var converted = Expression.Convert(decompiled.Arguments[0], typeof(ICollection <TTarget>));
var collectionExpression = Expression.Lambda <Func <T, ICollection <TTarget> > >(converted, navigationPropertyExpression.Parameters);
return(source.HasMany(collectionExpression));
}
public static ManyNavigationPropertyConfiguration <TEntityType, TTargetEntity> HasMany <TEntityType, TTargetEntity>(
this EntityTypeConfiguration <TEntityType> c,
Expression <Func <TEntityType, IEnumerable <TTargetEntity> > > navigationPropertyExpression) where TTargetEntity : class where TEntityType : class
{
var body = navigationPropertyExpression.Body;
var member = (PropertyInfo)((MemberExpression)body).Member;
cfg.RegisterForDecompilation(member);
var decompile = DecompileExpressionVisitor.Decompile(body);
var convert = Expression.Convert(decompile, typeof(ICollection <TTargetEntity>));
var expression = Expression.Lambda <Func <TEntityType, ICollection <TTargetEntity> > >(convert, navigationPropertyExpression.Parameters);
return(c.HasMany(expression));
}
public static string AddComputedToModel(Type modelType, object model, string modelName)
{
var sb = new StringBuilder();
if (modelType.IsClass && modelType.Namespace.Equals("System.Data.Entity.DynamicProxies"))
{
modelType = modelType.BaseType;
}
foreach (var property in modelType.GetProperties())
{
if (property.GetCustomAttributes(typeof(ComputedAttribute), false).Any())
{
sb.Append(modelName);
sb.Append('.');
sb.Append(property.Name);
sb.Append(" = ");
sb.Append("ko.computed(function() { try { return ");
sb.Append(ExpressionToString(modelType, DecompileExpressionVisitor.Decompile(Expression.Property(Expression.Constant(model), property))));
sb.Append(string.Format("}} catch(e) {{ return null; }} ;}}, {0});", modelName));
sb.AppendLine();
}
}
foreach (var property in modelType.GetProperties())
{
if (property.PropertyType.IsClass && !typeof(IEnumerable).IsAssignableFrom(property.PropertyType))
{
if (property.GetCustomAttributes(typeof(Newtonsoft.Json.JsonIgnoreAttribute), false).Length > 0)
{
continue;
}
object value;
try
{
value = property.GetValue(model, null);
sb.Append(AddComputedToModel(property.PropertyType, value, modelName + "." + property.Name));
}
catch
{
}
}
}
return(sb.ToString());
}
public static ManyNavigationPropertyConfiguration <TEntityType, TTargetEntity> HasMany <TEntityType, TTargetEntity>(
this EntityTypeConfiguration <TEntityType> c,
Expression <Func <TEntityType, IEnumerable <TTargetEntity> > > navigationPropertyExpression)
where TTargetEntity : class
where TEntityType : class
{
try
{
//The code that causes the error goes here.
var body = navigationPropertyExpression.Body;
var member = (PropertyInfo)((MemberExpression)body).Member;
cfg.RegisterForDecompilation(member);
var decompile = DecompileExpressionVisitor.Decompile(body);
var convert = Expression.Convert(decompile, typeof(ICollection <TTargetEntity>));
var expression = Expression.Lambda <Func <TEntityType, ICollection <TTargetEntity> > >(convert, navigationPropertyExpression.Parameters);
return(c.HasMany(expression));
}
catch (ReflectionTypeLoadException ex)
{
StringBuilder sb = new StringBuilder();
foreach (Exception exSub in ex.LoaderExceptions)
{
sb.AppendLine(exSub.Message);
FileNotFoundException exFileNotFound = exSub as FileNotFoundException;
if (exFileNotFound != null)
{
if (!string.IsNullOrEmpty(exFileNotFound.FusionLog))
{
sb.AppendLine("Fusion Log:");
sb.AppendLine(exFileNotFound.FusionLog);
}
}
sb.AppendLine();
}
string errorMessage = sb.ToString();
//Display or log the error based on your application.
throw;
}
}
/// <summary>
/// Allow use of IEnumerable in .Include
/// </summary>
/// <typeparam name="T">Source type</typeparam>
/// <typeparam name="TEnumerable">Type of enumerable to include</typeparam>
/// <param name="queryable">Queryable to be updated</param>
/// <param name="path">Expression for the IEnumerable</param>
/// <returns>A IQueryable with IEnumerable replaced by ICollection</returns>
public static IQueryable <T> Include <T, TEnumerable>(this IQueryable <T> queryable, Expression <Func <T, IEnumerable <TEnumerable> > > path)
{
var newPath = (Expression <Func <T, IEnumerable <TEnumerable> > >)DecompileExpressionVisitor.Decompile(path);
return(QueryableExtensions.Include(queryable, newPath));
}
public override IQueryable <TElement> CreateQuery <TElement>(Expression expression)
{
var decompiled = DecompileExpressionVisitor.Decompile(expression);
return(new AsyncDecompiledQueryable <TElement>(this, inner.CreateQuery <TElement>(decompiled)));
}
public override IQueryable <TElement> CreateQuery <TElement>(Expression expression)
{
var decompiled = DecompileExpressionVisitor.Decompile(expression);
return(new EntityQueryable <TElement>(this, decompiled));
}
// ReSharper disable once UnusedMember.Global
// ReSharper disable once VirtualMemberNeverOverridden.Global
public virtual TResult ExecuteAsync <TResult>(Expression expression, CancellationToken cancellationToken)
{
var decompiled = DecompileExpressionVisitor.Decompile(expression);
return((TResult)MethodCache <TResult> .ExecuteAsync(AsyncQueryProvider, decompiled, cancellationToken));
}
public virtual IAsyncEnumerable <TResult> ExecuteAsync <TResult>(Expression expression)
{
var decompiled = DecompileExpressionVisitor.Decompile(expression);
return((IAsyncEnumerable <TResult>) MethodCache <TResult> .ExecuteAsync(AsyncQueryProvider, decompiled));
}
public new virtual Task <TResult> ExecuteAsync <TResult>(Expression expression, CancellationToken cancellationToken)
{
var decompiled = DecompileExpressionVisitor.Decompile(expression);
return((Task <TResult>)ExecuteAsync <TResult>(AsyncQueryProvider, decompiled, cancellationToken));
}
