/// <summary>
        /// Returns a new ObjectQueryState instance with the specified navigation property path specified as an Include span.
        /// For eLINQ queries the Include operation is modelled as a method call expression applied to the source ObectQuery,
        /// so the <see cref="Span"/> property is always <c>null</c> on the returned instance.
        /// </summary>
        /// <typeparam name="TElementType">The element type of the resulting query</typeparam>
        /// <param name="sourceQuery">The ObjectQuery on which Include was called; required to build the new method call expression</param>
        /// <param name="includePath">The new Include path</param>
        /// <returns>A new ObjectQueryState instance that incorporates the Include path, in this case a new method call expression</returns>
        internal override ObjectQueryState Include <TElementType>(ObjectQuery <TElementType> sourceQuery, string includePath)
        {
            MethodInfo includeMethod = sourceQuery.GetType().GetMethod("Include", BindingFlags.Public | BindingFlags.Instance);

            Debug.Assert(includeMethod != null, "Unable to find ObjectQuery.Include method?");

            Expression       includeCall = Expression.Call(Expression.Constant(sourceQuery), includeMethod, new Expression[] { Expression.Constant(includePath, typeof(string)) });
            ObjectQueryState retState    = new ELinqQueryState(this.ElementType, this.ObjectContext, includeCall);

            this.ApplySettingsTo(retState);
            return(retState);
        }
Beispiel #2
0
        /// <summary>
        /// Provides an untyped method capable of creating a strong-typed ObjectQuery
        /// (based on the <paramref name="ofType"/> argument) and returning it as an
        /// instance of the untyped (in a generic sense) ObjectQuery base class.
        /// </summary>
        /// <param name="expression">The LINQ expression that defines the new query</param>
        /// <param name="ofType">The result type of the new ObjectQuery</param>
        /// <returns>A new ObjectQuery&lt;ofType&gt;, as an instance of ObjectQuery</returns>
        private ObjectQuery CreateQuery(Expression expression, Type ofType)
        {
            ObjectQueryState queryState;

            if (_query == null)
            {
                queryState = new ELinqQueryState(ofType, _context, expression);
            }
            else
            {
                queryState = new ELinqQueryState(ofType, _query, expression);
            }
            return(queryState.CreateQuery());
        }
Beispiel #3
0
        /// <summary>
        /// Creates a new query from an expression.
        /// </summary>
        /// <typeparam name="S">The element type of the query.</typeparam>
        /// <param name="expression">Expression forming the query.</param>
        /// <returns>A new ObjectQuery&lt;S&gt; instance.</returns>
        private ObjectQuery <S> CreateQuery <S>(Expression expression)
        {
            ObjectQueryState queryState;

            if (_query == null)
            {
                queryState = new ELinqQueryState(typeof(S), _context, expression);
            }
            else
            {
                queryState = new ELinqQueryState(typeof(S), _query, expression);
            }
            return(new ObjectQuery <S>(queryState));
        }