public QueryDeferred(IQueryable query, Expression expression) #endif { Expression = expression; #if EF5 || EF6 // CREATE query from the deferred expression var provider = ((IQueryable)query).Provider; var createQueryMethod = provider.GetType().GetMethod("CreateQuery", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(Expression), typeof(Type) }, null); Query = (IQueryable <TResult>)createQueryMethod.Invoke(provider, new object[] { expression, typeof(TResult) }); #elif EFCORE if (EFCoreHelper.IsVersion3x) { // EF Core 3.x Query = new EntityQueryable <TResult>((IAsyncQueryProvider)query.Provider, Expression); } else { // EF Core 2.x Query = new EntityQueryable <TResult>((IAsyncQueryProvider)query.Provider); var expressionProperty = typeof(QueryableBase <>).MakeGenericType(typeof(TResult)).GetProperty("Expression", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); expressionProperty.SetValue((QueryableBase <TResult>)Query, expression); } #endif }
public virtual ActionResult MultipleSelector(int page = 1, string parentpath = null, Guid?parentid = null) { if (!User.Identity.IsAuthenticated && !Metadata.AllowAnonymous) { return(new HttpStatusCodeResult(403)); } if (!Metadata.ViewRoles.All(t => User.IsInRole(t))) { return(new HttpStatusCodeResult(403)); } IQueryable <TEntity> queryable = EntityQueryable.Query(); if (parentpath != null && parentid.HasValue) { try { queryable = EntityQueryable.InParent(queryable, parentpath, parentid.Value); } catch { return(new HttpStatusCodeResult(400)); } } var model = new EntityViewModel <TEntity>(EntityQueryable.OrderBy(queryable), page, 10); if (Metadata.ParentProperty != null) { model.Parent = GetParentModel(parentid, 3); } model.Headers = Metadata.ViewProperties; model.UpdateItems(); return(View(model)); }
public virtual ActionResult Edit(Guid id) { if (!EntityQueryable.Editable()) { return(new HttpStatusCodeResult(403)); } if (!User.Identity.IsAuthenticated && !Metadata.AllowAnonymous) { return(new HttpStatusCodeResult(403)); } if (!Metadata.EditRoles.All(t => User.IsInRole(t))) { return(new HttpStatusCodeResult(403)); } TEntity item = EntityQueryable.GetEntity(id); if (item == null) { return(new HttpStatusCodeResult(404)); } var model = new EntityEditModel <TEntity>(item); model.Properties = Metadata.EditProperties; return(View(model)); }
public virtual async Task <EntityViewer> GetViewer() { EntityViewModel <TEntity> model = await GetViewModel(EntityQueryable.OrderBy(), 1, 20); EntityViewer viewer = new EntityViewer(); viewer.Model = model; return(viewer); }
public virtual async Task <EntityMultipleSelector> GetMultipleSelector() { EntityViewModel <TEntity> model = await GetMultipleSelectorModel(EntityQueryable.OrderBy()); EntityMultipleSelector selector = new EntityMultipleSelector(); selector.Model = model; return(selector); }
public virtual async Task <bool> Update(TEntity entity) { if (entity.Index == Guid.Empty) { return(await EntityQueryable.AddAsync(entity)); } else { return(await EntityQueryable.EditAsync(entity)); } }
private EntityQueryable <TEntity> CreateEntityQueryable() { var queryable = new EntityQueryable <TEntity>(_context.GetDependencies().QueryProvider); #pragma warning disable 618 if (_entityType.FindPrimaryKey() == null) #pragma warning restore 618 { queryable = (EntityQueryable <TEntity>)queryable.AsNoTracking(); } return(queryable); }
/// <summary> /// The starting point for your query. Make sure <typeparamref name="TEntity"/> is available as a <see cref="DbSet{TEntity}"/> on your <see cref="DbContext"/>. /// </summary> /// <typeparam name="TEntity">The type of the entities.</typeparam> /// <param name="contextFactory">The factory which can create the <see cref="DbContext"/>.</param> /// <returns></returns> public static IQueryable <TEntity> Set <TEntity>(this IDbContextFactory <DbContext> contextFactory) where TEntity : class { if (contextFactory is null) { throw new System.ArgumentNullException(nameof(contextFactory)); } var query = new EntityQueryable <TEntity>( new QueryProvider(new DbContextFactoryQueryContext <DbContext, TEntity>(contextFactory)), new EntityType <TEntity>()); return(query); }
public virtual ActionResult Detail(Guid id) { if (!Metadata.ViewRoles.All(t => User.IsInRole(t))) { return(new HttpStatusCodeResult(403)); } TEntity item = EntityQueryable.GetEntity(id); if (item == null) { return(new HttpStatusCodeResult(404)); } var model = new EntityEditModel <TEntity>(item); model.Properties = Metadata.DetailProperties; return(View(model)); }
public void Setup() { _mappings = new TestMappingsRepository(new QueryableTests.NamedGraphsPersonMapping()); _baseUriSelectionPolicy = new Mock <IBaseUriSelectionPolicy>(); _baseUriSelectionPolicy.Setup(policy => policy.SelectBaseUri(It.IsAny <EntityId>())).Returns(new Uri("http://test/")); _entitySource = new Mock <IEntitySource>(MockBehavior.Strict); _store = new Mock <IEntityStore>(MockBehavior.Strict); _store.Setup(store => store.AssertEntity(It.IsAny <EntityId>(), It.IsAny <IEnumerable <IEntityQuad> >())); _entityContext = new Mock <IEntityContext>(MockBehavior.Strict); _entityContext.Setup(context => context.Create <IPerson>(It.IsAny <EntityId>())).Returns((EntityId id) => CreatePersonEntity(id)); _entityContext.SetupGet(context => context.Mappings).Returns(_mappings); _entityContext.SetupGet(context => context.BaseUriSelector).Returns(_baseUriSelectionPolicy.Object); _persons = new EntityQueryable <IPerson>(_entityContext.Object, _entitySource.Object, _store.Object); _testQueries = GetTestQueries(); }
public void Setup() { _mappings = new TestMappingsRepository(new QueryableTests.NamedGraphsPersonMapping()); _baseUriSelectionPolicy = new Mock<IBaseUriSelectionPolicy>(); _baseUriSelectionPolicy.Setup(policy => policy.SelectBaseUri(It.IsAny<EntityId>())).Returns(new Uri("http://test/")); _entitySource = new Mock<IEntitySource>(MockBehavior.Strict); _entityStore = new Mock<IEntityStore>(MockBehavior.Strict); _entityStore.Setup(store => store.AssertEntity(It.IsAny<EntityId>(), It.IsAny<IEnumerable<EntityQuad>>())); _entityContext = new Mock<IEntityContext>(MockBehavior.Strict); _entityContext.Setup(context => context.Load<IPerson>(It.IsAny<EntityId>())).Returns((EntityId id) => CreatePersonEntity(id)); _entityContext.Setup(context => context.Store).Returns(_entityStore.Object); _entityContext.SetupGet(context => context.Mappings).Returns(_mappings); _entityContext.SetupGet(context => context.BaseUriSelector).Returns(_baseUriSelectionPolicy.Object); _persons = new EntityQueryable<IPerson>(_entityContext.Object, _entitySource.Object, _mappings, _baseUriSelectionPolicy.Object); _testQueries = GetTestQueries(); }
public static void LINQ_ToString() { using (var ctx = new WWWingsContext()) { ctx.Log(); var q1 = from p in ctx.FlightSet where p.FlightNo < 10 orderby p.FreeSeats select p; EntityQueryable <Flight> q1b = (EntityQueryable <Flight>)q1; Console.WriteLine(q1.ToString()); // EF: returns SQL. EFC: returns type :-( Console.WriteLine(q1b.ToString()); // EF: returns SQL. EFC: returns type :-( } }
public virtual ActionResult Remove(Guid id) { if (!EntityQueryable.Removeable()) { return(new HttpStatusCodeResult(403)); } if (!Metadata.RemoveRoles.All(t => User.IsInRole(t))) { return(new HttpStatusCodeResult(403)); } if (EntityQueryable.Remove(id)) { return(new HttpStatusCodeResult(200)); } else { return(new HttpStatusCodeResult(404)); } }
public virtual ActionResult Create(Guid?parent = null) { if (!EntityQueryable.Addable()) { return(new HttpStatusCodeResult(403)); } if (!Metadata.AddRoles.All(t => User.IsInRole(t))) { return(new HttpStatusCodeResult(403)); } var model = new EntityEditModel <TEntity>(EntityQueryable.Create()); model.Item.Index = Guid.Empty; model.Properties = Metadata.EditProperties; if (parent != null && model.Metadata.ParentProperty != null) { dynamic parentContext = EntityBuilder.GetContext(model.Metadata.ParentProperty.Property.PropertyType); object parentObj = parentContext.GetEntity(parent.Value); model.Metadata.ParentProperty.Property.SetValue(model.Item, parentObj); } return(View("Edit", model)); }
public static IQueryable <T> FromSql <T>(this DbContext dbContext, RawSqlString sql, params object[] parameters) { // Argument check if (dbContext == null) { throw new ArgumentNullException(nameof(dbContext)); } // Add new query type if not exists dbContext.TryAddQueryType <T>(); // Get the query provider service instance var queryProvider = dbContext.GetDependencies().QueryProvider; // Build query source. Actually query source is just used to determine the final result item type. var querySource = new EntityQueryable <T>(queryProvider); // Build LINQ expression for Entity Framework Core. var expression = Expression.Call(null, FromSqlMethod.MakeGenericMethod(typeof(T)), querySource.Expression, Expression.Constant(sql), Expression.Constant(parameters)); // Return result return(queryProvider.CreateQuery <T>(expression)); }
public async Task ExecuteAsync_UsesSpecifiedContentType() { // Arrange var executor = CreateExecutor(); var httpContext = new DefaultHttpContext(); var actionContext = new ActionContext() { HttpContext = httpContext }; httpContext.Request.Headers[HeaderNames.Accept] = "application/json"; // This will not be used httpContext.Response.ContentType = "application/json"; IList <Customer> customers = new List <Customer>(); IQueryable <Customer> customersQuery = customers.AsQueryable <Customer>(); CustomersContext db = new CustomersContext(); // db.Customers Expression expression = Expression.Constant("abc"); EntityQueryable <Customer> value = new EntityQueryable <Customer>(db.GetDependencies().QueryProvider, expression); var result = new ObjectResult(value) { ContentTypes = { "application/json", }, }; result.Formatters.Add(new TestJsonOutputFormatter()); // Act await executor.ExecuteAsync(actionContext, result); // Assert // MediaTypeAssert.Equal("text/xml; charset=utf-8", httpContext.Response.ContentType); }
public ExpressionTranslater(Expression root, EntityQueryable <T> entityQuery) { this.root = root; this.EntityQuery = entityQuery; }
/// <summary>Executes the given expression.</summary> /// <exception cref="Exception">Thrown when an exception error condition occurs.</exception> /// <typeparam name="TResult">Type of the result.</typeparam> /// <param name="expression">The expression to execute.</param> /// <returns>The object returned by the execution of the expression.</returns> public TResult Execute <TResult>(Expression expression) { var methodCall = expression as MethodCallExpression; if (methodCall == null) { throw new Exception(ExceptionMessage.GeneralException); } if (methodCall.Method.Name == "All" || methodCall.Method.Name == "Any" || methodCall.Method.Name == "Average" || methodCall.Method.Name == "Contains" || methodCall.Method.Name == "Count" || methodCall.Method.Name == "LongCount" || methodCall.Method.Name == "Max" || methodCall.Method.Name == "Min" || methodCall.Method.Name == "SequenceEqual" || methodCall.Method.Name == "Sum") { return(OriginalProvider.Execute <TResult>(expression)); } QueryIncludeOptimizedIncludeSubPath.RemoveLazyChild(CurrentQueryable); var currentQuery = CurrentQueryable; var currentMethod = methodCall.Method.GetGenericMethodDefinition(); // CHECK if the internal expression can be supported var isExpressionSupported = false; var firstExpression = methodCall.Arguments.FirstOrDefault(x => x.Type.IsSubclassOf(typeof(Expression))); if (firstExpression != null && methodCall.Arguments.Count == 2) { var quoteExpression = ((UnaryExpression)firstExpression).Operand; var lambdaExpression = quoteExpression as LambdaExpression; if (lambdaExpression != null) { if (lambdaExpression.Type == typeof(Func <,>).MakeGenericType(currentQuery.ElementType, typeof(bool))) { var method = typeof(Queryable).GetMethods().First(x => x.Name == "Where" && x.GetParameters()[1].ParameterType.GetGenericArguments()[0].GetGenericArguments().Length == 2); var methodGeneric = method.MakeGenericMethod(currentQuery.ElementType); currentQuery = (QueryIncludeOptimizedParentQueryable <T>)methodGeneric.Invoke(null, new object[] { currentQuery, lambdaExpression }); currentMethod = typeof(Queryable).GetMethods().FirstOrDefault(x => x.Name == currentMethod.Name && x.GetParameters().Length == 1); isExpressionSupported = currentMethod != null; } } } if (firstExpression != null && !isExpressionSupported) { throw new Exception(ExceptionMessage.QueryIncludeOptimized_ArgumentExpression); } // CREATE the new query by selecting included entities in an anonymous type var newQuery = currentQuery; // REPLACE the first argument with the new query expression var arguments = methodCall.Arguments.ToList(); arguments[0] = newQuery.Expression; // REMOVE the last argument if a "Predicate" method was previously used if (firstExpression != null) { arguments.RemoveAt(1); } // RESOLE parent queries using .FutureValue(); #if EFCORE_3X var immediateQuery = new EntityQueryable <TResult>((IAsyncQueryProvider)OriginalProvider, expression); #elif EF5 || EF6 var objectQuery = CurrentQueryable.OriginalQueryable.GetObjectQuery(); // GET provider // because IQueryable.Provider call : ObjectQueryProvider and now that work for EF5 var objectQueryProviderField = typeof(ObjectQuery).GetProperty("System.Linq.IQueryable.Provider", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); var provider = (IQueryProvider)objectQueryProviderField.GetValue(objectQuery, null); // CREATE query from the expression var createQueryMethod = provider.GetType().GetMethod("CreateQuery", BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(Expression) }, null); createQueryMethod = createQueryMethod.MakeGenericMethod(typeof(TResult)); var immediateQuery = (ObjectQuery <T>)createQueryMethod.Invoke(provider, new object[] { expression }); #endif object value = null; if (QueryIncludeOptimizedManager.AllowQueryBatch) { var futureValue = immediateQuery.FutureValue(); // RESOLVE child queries using .Future() { // MODIFY query if necessary #if EF5 || EF6 var objectContext = CurrentQueryable.OriginalQueryable.GetObjectQuery().Context; var keyMembers = objectContext.GetEntitySet <T>().ElementType.KeyMembers; var keyNames = ((IEnumerable <EdmMember>)keyMembers).Select(x => x.Name).ToArray(); #elif EFCORE var context = currentQuery.OriginalQueryable.GetDbContext(); var keyNames = context.Model.FindEntityType(typeof(TResult).DisplayName(true)) .GetKeys().ToList()[0] .Properties.Select(x => x.Name).ToArray(); #endif var currentNewQuery = methodCall.Method.Name == "First" || methodCall.Method.Name == "FirstOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Take(1) : methodCall.Method.Name == "Last" || methodCall.Method.Name == "LastOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Reverse().Take(1) : currentQuery; currentQuery.CreateQueryable(currentNewQuery); } value = futureValue.Value; } else { #if EFCORE_3X value = immediateQuery.FutureValue().Value; #else value = immediateQuery.Execute(objectQuery.MergeOption).FirstOrDefault(); #endif // RESOLVE child queries using .Future() { // MODIFY query if necessary #if EF5 || EF6 var objectContext = CurrentQueryable.OriginalQueryable.GetObjectQuery().Context; var keyMembers = ((dynamic)objectContext).CreateObjectSet <T>().EntitySet.ElementType.KeyMembers; var keyNames = ((IEnumerable <EdmMember>)keyMembers).Select(x => x.Name).ToArray(); #elif EFCORE var context = currentQuery.OriginalQueryable.GetDbContext(); var keyNames = context.Model.FindEntityType(typeof(TResult).DisplayName(true)) .GetKeys().ToList()[0] .Properties.Select(x => x.Name).ToArray(); #endif var currentNewQuery = methodCall.Method.Name == "First" || methodCall.Method.Name == "FirstOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Take(1) : methodCall.Method.Name == "Last" || methodCall.Method.Name == "LastOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Reverse().Take(1) : currentQuery; currentQuery.CreateQueryable(currentNewQuery); } } // EXECUTE the new expression //var value = QueryIncludeOptimizedManager.AllowQueryBatch ? immediateQuery.FutureValue().Value : immediateQuery.FirstOrDefault(); // CHECK if a value has been returned if (value == null) { return((TResult)(object)null); } #if EF6 // FIX lazy loading QueryIncludeOptimizedLazyLoading.SetLazyLoaded(value, CurrentQueryable.Childs); #endif // FIX null collection QueryIncludeOptimizedNullCollection.NullCollectionToEmpty(value, CurrentQueryable.Childs); #if EF5 || EF6 return((TResult)(object)value); #elif EFCORE return((TResult)value); #endif }
protected virtual Task <EntityViewModel <TEntity> > GetViewModel(IQueryable <TEntity> queryable, int page, int size) { return(Task.Run <EntityViewModel <TEntity> >(() => { EntityViewModel <TEntity> model = new EntityViewModel <TEntity>(queryable, page, size); model.Headers = Metadata.ViewProperties; EntityViewButton createButton = new EntityViewButton(); createButton.Name = "Create"; createButton.GetInvokeDelegate = new EntityViewButtonCommandDelegate(viewer => { return new Task(async() => { var item = EntityQueryable.Create(); bool?result = null; await viewer.Dispatcher.Invoke(async() => { viewer.IsLoading = true; var editor = await GetEditor(item); result = editor.ShowDialog(); }); if (result == true) { await Update(item); model.UpdateTotalPage(); model.Items = model.Items.Concat(new TEntity[] { item }).ToArray(); } viewer.Dispatcher.Invoke(() => { viewer.IsLoading = false; }); }); }); model.ViewButtons = new IViewButton[] { createButton }; EntityItemButton editButton = new EntityItemButton(); editButton.Name = "Edit"; editButton.GetInvokeDelegate = new EntityItemButtonCommandDelegate((viewer, entity) => { return new Task(async() => { var item = (TEntity)entity; bool?result = null; await viewer.Dispatcher.Invoke(async() => { viewer.IsLoading = true; var editor = await GetEditor(item); result = editor.ShowDialog(); }); if (result == true) { await Update(item); } viewer.Dispatcher.Invoke(() => { viewer.IsLoading = false; }); }); }); EntityItemButton removeButton = new EntityItemButton(); removeButton.Name = "Remove"; removeButton.GetInvokeDelegate = new EntityItemButtonCommandDelegate((viewer, entity) => { return new Task(async() => { viewer.Dispatcher.Invoke(() => { viewer.IsLoading = true; }); await EntityQueryable.RemoveAsync(entity.Index); model.Items = await EntityQueryable.ToArrayAsync(queryable.Skip(page).Take(size)); viewer.Dispatcher.Invoke(() => { viewer.IsLoading = false; }); }); }); model.ItemButtons = new IEntityViewButton[] { editButton, removeButton }; return model; })); }
IEnumerator IEnumerable.GetEnumerator() => EntityQueryable.GetEnumerator();
IEnumerator <TEntity> IEnumerable <TEntity> .GetEnumerator() => EntityQueryable.GetEnumerator();
/// <summary>Executes the given expression.</summary> /// <exception cref="Exception">Thrown when an exception error condition occurs.</exception> /// <typeparam name="TResult">Type of the result.</typeparam> /// <param name="expression">The expression to execute.</param> /// <returns>The object returned by the execution of the expression.</returns> public TResult Execute <TResult>(Expression expression) { var methodCall = expression as MethodCallExpression; if (methodCall == null) { throw new Exception(ExceptionMessage.GeneralException); } var currentQuery = CurrentQueryable; var currentMethod = methodCall.Method.GetGenericMethodDefinition(); // CHECK if the internal expression can be supported] var isExpressionSupported = false; var firstExpression = methodCall.Arguments.FirstOrDefault(x => x.Type.IsSubclassOf(typeof(Expression))); if (firstExpression != null && methodCall.Arguments.Count == 2) { var quoteExpression = ((UnaryExpression)firstExpression).Operand; var lambdaExpression = quoteExpression as LambdaExpression; if (lambdaExpression != null) { if (lambdaExpression.Type == typeof(Func <,>).MakeGenericType(currentQuery.ElementType, typeof(bool))) { var method = typeof(Queryable).GetMethods().First(x => x.Name == "Where" && x.GetParameters()[1].ParameterType.GetGenericArguments()[0].GetGenericArguments().Length == 2); var methodGeneric = method.MakeGenericMethod(currentQuery.ElementType); currentQuery = (QueryIncludeOptimizedParentQueryable <T>)methodGeneric.Invoke(null, new object[] { currentQuery, lambdaExpression }); currentMethod = typeof(Queryable).GetMethods().FirstOrDefault(x => x.Name == currentMethod.Name && x.GetParameters().Length == 1); isExpressionSupported = currentMethod != null; } } } if (firstExpression != null && !isExpressionSupported) { throw new Exception(ExceptionMessage.QueryIncludeOptimized_ArgumentExpression); } // CREATE the new query by selecting included entities in an anonymous type var newQuery = currentQuery; // REPLACE the first argument with the new query expression var arguments = methodCall.Arguments.ToList(); arguments[0] = newQuery.Expression; // REMOVE the last argument if a "Predicate" method was previously used if (firstExpression != null) { arguments.RemoveAt(1); } // RESOLVE child queries using .Future() { // MODIFY query if necessary #if EF5 || EF6 var objectContext = CurrentQueryable.OriginalQueryable.GetObjectQuery().Context; var keyMembers = ((dynamic)objectContext).CreateObjectSet <T>().EntitySet.ElementType.KeyMembers; var keyNames = ((IEnumerable <EdmMember>)keyMembers).Select(x => x.Name).ToArray(); #elif EF7 var context = currentQuery.OriginalQueryable.GetDbContext(); var keyNames = context.Model.FindEntityType(typeof(TResult).DisplayName(true)) .GetKeys().ToList()[0] .Properties.Select(x => x.Name).ToArray(); #endif var currentNewQuery = methodCall.Method.Name == "First" || methodCall.Method.Name == "FirstOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Take(1) : methodCall.Method.Name == "Last" || methodCall.Method.Name == "LastOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Reverse().Take(1) : currentQuery; currentQuery.CreateQueryable(currentNewQuery); } // RESOLE parent queries using .FutureValue(); #if EF5 || EF6 var objectQuery = CurrentQueryable.OriginalQueryable.GetObjectQuery(); // GET provider var objectQueryProviderField = typeof(ObjectQuery).GetField("_provider", BindingFlags.NonPublic | BindingFlags.Instance); var provider = (IQueryProvider)objectQueryProviderField.GetValue(objectQuery); // CREATE query from the expression var createQueryMethod = provider.GetType().GetMethod("CreateQuery", BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(Expression) }, null); createQueryMethod = createQueryMethod.MakeGenericMethod(typeof(TResult)); var immediateQuery = (ObjectQuery <T>)createQueryMethod.Invoke(provider, new object[] { expression }); #elif EF7 var immediateQuery = new EntityQueryable <TResult>((IAsyncQueryProvider)OriginalProvider); var expressionProperty = typeof(QueryableBase <>).MakeGenericType(typeof(TResult)).GetProperty("Expression", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); expressionProperty.SetValue(immediateQuery, expression); #endif // EXECUTE the new expression var futureValue = immediateQuery.FutureValue(); var value = futureValue.Value; // CHECK if a value has been returned if (value == null) { return((TResult)(object)null); } #if EF5 || EF6 return((TResult)(object)value); #elif EF7 return((TResult)value); #endif }
public DbSet([NotNull] DbContext context) : base(Check.NotNull(context, "context")) { _entityQueryable = new EntityQueryable <TEntity>(new EntityQueryExecutor(context)); }
/// <summary> /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to /// the same compatibility standards as public APIs. It may be changed or removed without notice in /// any release. You should only use it directly in your code with extreme caution and knowing that /// doing so can result in application failures when updating to a new Entity Framework Core release. /// </summary> IAsyncEnumerator <TEntity> IAsyncEnumerable <TEntity> .GetAsyncEnumerator(CancellationToken cancellationToken) => EntityQueryable.GetAsyncEnumerator(cancellationToken);
public virtual ActionResult Update(Guid id) { TEntity entity; if (id == Guid.Empty) { if (!EntityQueryable.Addable()) { return(new HttpStatusCodeResult(403)); } if (!Metadata.AddRoles.All(t => User.IsInRole(t))) { return(new HttpStatusCodeResult(403)); } entity = EntityQueryable.Create(); } else { if (!EntityQueryable.Editable()) { return(new HttpStatusCodeResult(403)); } if (!Metadata.EditRoles.All(t => User.IsInRole(t))) { return(new HttpStatusCodeResult(403)); } entity = EntityQueryable.GetEntity(id); if (entity == null) { return(new HttpStatusCodeResult(404)); } } var properties = Metadata.Properties.Where(t => !t.IsHiddenOnEdit).ToArray(); for (int i = 0; i < properties.Length; i++) { PropertyMetadata propertyMetadata = properties[i]; if (propertyMetadata.Type == ComponentModel.DataAnnotations.CustomDataType.File || propertyMetadata.Type == ComponentModel.DataAnnotations.CustomDataType.Image) { #region File Path Value if (!Request.Files.AllKeys.Contains(propertyMetadata.Property.Name)) { continue; } if (!(this is IFileController <TEntity>)) { throw new NotSupportedException("Controller doesn't support upload file."); } ((IFileController <TEntity>) this).SaveFileToProperty(entity, propertyMetadata, Request.Files[propertyMetadata.Property.Name]); #endregion } else { #region Property Value if (!Request.Form.AllKeys.Contains(propertyMetadata.Property.Name)) { if (id == Guid.Empty && propertyMetadata.IsRequired) { Response.StatusCode = 400; return(Content(propertyMetadata.Name + "为必填项")); } continue; } string originValue = Request.Form[propertyMetadata.Property.Name]; if (string.IsNullOrEmpty(originValue) && propertyMetadata.Property.PropertyType != typeof(string) && propertyMetadata.IsRequired) { Response.StatusCode = 400; return(Content(propertyMetadata.Name + "为必填项")); } //Type type = propertyMetadata.Property.PropertyType; //if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>)) // type = type.GetGenericArguments()[0]; TypeConverter converter = EntityValueConverter.GetConverter(propertyMetadata); if (converter == null) { if (propertyMetadata.Property.PropertyType.IsGenericType && propertyMetadata.Property.PropertyType.GetGenericTypeDefinition() == typeof(ICollection <>)) { converter = new Converter.CollectionConverter(); } else if (propertyMetadata.Property.PropertyType.IsEnum) { converter = new EnumConverter(propertyMetadata.Property.PropertyType); } else if (propertyMetadata.Type != ComponentModel.DataAnnotations.CustomDataType.Password) { throw new NotSupportedException("Type of \"" + propertyMetadata.Property.PropertyType.Name + "\" converter not found."); } } if (propertyMetadata.Type == ComponentModel.DataAnnotations.CustomDataType.Password && entity is IPassword) { object v = propertyMetadata.Property.GetValue(entity); if (v == null || originValue != v.ToString()) { ((IPassword)entity).SetPassword(originValue); } } else { EntityValueConverterContext context = new EntityValueConverterContext(EntityBuilder.DescriptorContext, propertyMetadata); object value = converter.ConvertFrom(context, null, originValue); if (converter.GetType() == typeof(Converter.CollectionConverter)) { object collection = propertyMetadata.Property.GetValue(entity); ((dynamic)collection).Clear(); var addMethod = collection.GetType().GetMethod("Add"); object[] array = (object[])value; for (int a = 0; a < array.Length; a++) { addMethod.Invoke(collection, new object[] { array[a] }); } } else { propertyMetadata.Property.SetValue(entity, value); } } #endregion } } var validateResult = entity.Validate(null); if (validateResult.Count() != 0) { Response.StatusCode = 400; return(Content(new string(validateResult.SelectMany(t => t.ErrorMessage += "/r/n").ToArray()))); } bool result; if (id == Guid.Empty) { result = EntityQueryable.Add(entity); } else { result = EntityQueryable.Edit(entity); } if (result) { return(Content(entity.Index.ToString())); } else { Response.StatusCode = 400; return(Content("未知")); } }
private MainFromClause CreateWithEntityQueryable <T>() { var queryable = new EntityQueryable <T>(new EntityQueryExecutor(Mock.Of <DbContext>())); return(new MainFromClause("s", typeof(T), Expression.Constant(queryable))); }
protected virtual async Task <EntityEditModel <TEntity> > GetEditModel(Guid id) { var item = await EntityQueryable.GetEntityAsync(id); return(await GetEditModel(item)); }
public DbQueryProvider(EntityQueryable <T> entityQuery) : base() { this.entityQuery = entityQuery; }
/// <summary>Executes the given expression.</summary> /// <exception cref="Exception">Thrown when an exception error condition occurs.</exception> /// <typeparam name="TResult">Type of the result.</typeparam> /// <param name="expression">The expression to execute.</param> /// <returns>The object returned by the execution of the expression.</returns> public TResult Execute <TResult>(Expression expression) { var methodCall = expression as MethodCallExpression; if (methodCall == null) { throw new Exception(ExceptionMessage.GeneralException); } if (methodCall.Method.Name == "All" || methodCall.Method.Name == "Any" || methodCall.Method.Name == "Average" || methodCall.Method.Name == "Contains" || methodCall.Method.Name == "Count" || methodCall.Method.Name == "LongCount" || methodCall.Method.Name == "Max" || methodCall.Method.Name == "Min" || methodCall.Method.Name == "SequenceEqual" || methodCall.Method.Name == "Sum") { return(OriginalProvider.Execute <TResult>(expression)); } QueryIncludeFilterIncludeSubPath.RemoveLazyChild(CurrentQueryable); var currentQuery = CurrentQueryable; var currentMethod = methodCall.Method.GetGenericMethodDefinition(); // CHECK if the internal expression can be supported var isExpressionSupported = false; var firstExpression = methodCall.Arguments.FirstOrDefault(x => x.Type.IsSubclassOf(typeof(Expression))); if (firstExpression != null && methodCall.Arguments.Count == 2) { var quoteExpression = ((UnaryExpression)firstExpression).Operand; var lambdaExpression = quoteExpression as LambdaExpression; if (lambdaExpression != null) { if (lambdaExpression.Type == typeof(Func <,>).MakeGenericType(currentQuery.ElementType, typeof(bool))) { var method = typeof(Queryable).GetMethods().First(x => x.Name == "Where" && x.GetParameters()[1].ParameterType.GetGenericArguments()[0].GetGenericArguments().Length == 2); var methodGeneric = method.MakeGenericMethod(currentQuery.ElementType); currentQuery = (QueryIncludeFilterParentQueryable <T>)methodGeneric.Invoke(null, new object[] { currentQuery, lambdaExpression }); currentMethod = typeof(Queryable).GetMethods().FirstOrDefault(x => x.Name == currentMethod.Name && x.GetParameters().Length == 1); isExpressionSupported = currentMethod != null; } } } if (firstExpression != null && !isExpressionSupported) { throw new Exception(ExceptionMessage.QueryIncludeFilter_ArgumentExpression); } // CREATE the new query by selecting included entities in an anonymous type var newQuery = currentQuery; // REPLACE the first argument with the new query expression var arguments = methodCall.Arguments.ToList(); arguments[0] = newQuery.Expression; // REMOVE the last argument if a "Predicate" method was previously used if (firstExpression != null) { arguments.RemoveAt(1); } #if EFCORE_3X // RESOLE parent queries using .FutureValue(); var immediateQuery = new EntityQueryable <TResult>((IAsyncQueryProvider)OriginalProvider, expression); #else // RESOLE parent queries using .FutureValue(); var immediateQuery = new EntityQueryable <TResult>((IAsyncQueryProvider)OriginalProvider); var expressionProperty = typeof(QueryableBase <>).MakeGenericType(typeof(TResult)).GetProperty("Expression", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); expressionProperty.SetValue(immediateQuery, expression); #endif object value = null; DbContext context = null; if (currentQuery.OriginalQueryable.IsInMemoryQueryContext()) { context = currentQuery.OriginalQueryable.GetInMemoryContext(); } else { // MODIFY query if necessary context = currentQuery.OriginalQueryable.GetDbContext(); } if (QueryIncludeFilterManager.AllowQueryBatch) { var futureValue = immediateQuery.FutureValue(); // RESOLVE child queries using .Future() { // MODIFY query if necessary var keyNames = context.Model.FindEntityType(typeof(TResult).DisplayName(true)) .GetKeys().ToList()[0] .Properties.Select(x => x.Name).ToArray(); var currentNewQuery = methodCall.Method.Name == "First" || methodCall.Method.Name == "FirstOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Take(1) : methodCall.Method.Name == "Last" || methodCall.Method.Name == "LastOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Reverse().Take(1) : currentQuery; currentQuery.CreateQueryable(currentNewQuery); } value = futureValue.Value; } else { // TODO: Find a better way value = immediateQuery.FutureValue().Value; //value = immediateQuery.Execute(objectQuery.MergeOption).FirstOrDefault(); // RESOLVE child queries using .Future() { // MODIFY query if necessary var keyNames = context.Model.FindEntityType(typeof(TResult).DisplayName(true)) .GetKeys().ToList()[0] .Properties.Select(x => x.Name).ToArray(); var currentNewQuery = methodCall.Method.Name == "First" || methodCall.Method.Name == "FirstOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Take(1) : methodCall.Method.Name == "Last" || methodCall.Method.Name == "LastOrDefault" ? currentQuery.AddToRootOrAppendOrderBy(keyNames).Reverse().Take(1) : currentQuery; currentQuery.CreateQueryable(currentNewQuery); } } // EXECUTE the new expression //var value = QueryIncludeFilterManager.AllowQueryBatch ? immediateQuery.FutureValue().Value : immediateQuery.FirstOrDefault(); // CHECK if a value has been returned if (value == null) { return((TResult)(object)null); } // FIX null collection QueryIncludeFilterNullCollection.NullCollectionToEmpty(value, CurrentQueryable.Childs); return((TResult)value); }