DataServiceQueryProvider.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / DataWeb / Client / System / Data / Services / Client / ALinq / DataServiceQueryProvider.cs / 1625574 / DataServiceQueryProvider.cs
                        

                        
                            //---------------------------------------------------------------------- 
// 
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//  
//      Query Provider for Linq to URI translatation
//  
// 
// @owner  [....]
//--------------------------------------------------------------------- 

namespace System.Data.Services.Client
{
    #region Namespaces. 

    using System; 
    using System.Collections.Generic; 
    using System.Diagnostics;
    using System.Linq; 
    using System.Linq.Expressions;
    using System.Reflection;

    #endregion Namespaces. 

    ///  
    /// QueryProvider implementation 
    /// 
    internal sealed class DataServiceQueryProvider : IQueryProvider 
    {
        /// DataServiceContext for query provider
        internal readonly DataServiceContext Context;
 
        /// Constructs a query provider based on the context passed in 
        /// The context for the query provider 
        internal DataServiceQueryProvider(DataServiceContext context) 
        {
            this.Context = context; 
        }

        #region IQueryProvider implementation
 
        /// Factory method for creating DataServiceOrderedQuery based on expression 
        /// The expression for the new query 
        /// new DataServiceQuery 
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "parameters are validated against null via CheckArgumentNull")]
        public IQueryable CreateQuery(Expression expression) 
        {
            Util.CheckArgumentNull(expression, "expression");
            Type et = TypeSystem.GetElementType(expression.Type);
            Type qt = typeof(DataServiceQuery<>.DataServiceOrderedQuery).MakeGenericType(et); 
            object[] args = new object[] { expression, this };
 
            ConstructorInfo ci = qt.GetConstructor( 
                BindingFlags.NonPublic | BindingFlags.Instance,
                null, 
                new Type[] { typeof(Expression), typeof(DataServiceQueryProvider) },
                null);

            return (IQueryable)Util.ConstructorInvoke(ci, args); 
        }
 
        /// Factory method for creating DataServiceOrderedQuery based on expression  
        /// generic type
        /// The expression for the new query 
        /// new DataServiceQuery
        public IQueryable CreateQuery(Expression expression)
        {
            Util.CheckArgumentNull(expression, "expression"); 
            return new DataServiceQuery.DataServiceOrderedQuery(expression, this);
        } 
 
        /// Creates and executes a DataServiceQuery based on the passed in expression
        /// The expression for the new query 
        /// the results
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "parameters are validated against null via CheckArgumentNull")]
        [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.NoInlining | System.Runtime.CompilerServices.MethodImplOptions.NoOptimization)]
        public object Execute(Expression expression) 
        {
            Util.CheckArgumentNull(expression, "expression"); 
 
            MethodInfo mi = typeof(DataServiceQueryProvider).GetMethod("ReturnSingleton", BindingFlags.NonPublic | BindingFlags.Instance);
            return mi.MakeGenericMethod(expression.Type).Invoke(this, new object[] { expression }); 
        }

        /// Creates and executes a DataServiceQuery based on the passed in expression
        /// generic type 
        /// The expression for the new query
        /// the results 
        public TResult Execute(Expression expression) 
        {
            Util.CheckArgumentNull(expression, "expression"); 
            return ReturnSingleton(expression);
        }

        #endregion 

        /// Creates and executes a DataServiceQuery based on the passed in expression which results a single value 
        /// generic type 
        /// The expression for the new query
        /// single valued results 
        internal TElement ReturnSingleton(Expression expression)
        {
            IQueryable query = new DataServiceQuery.DataServiceOrderedQuery(expression, this);
 
            MethodCallExpression mce = expression as MethodCallExpression;
            Debug.Assert(mce != null, "mce != null"); 
 
            SequenceMethod sequenceMethod;
            if (ReflectionUtil.TryIdentifySequenceMethod(mce.Method, out sequenceMethod)) 
            {
                switch (sequenceMethod)
                {
                    case SequenceMethod.Single: 
                        return query.AsEnumerable().Single();
                    case SequenceMethod.SingleOrDefault: 
                        return query.AsEnumerable().SingleOrDefault(); 
                    case SequenceMethod.First:
                        return query.AsEnumerable().First(); 
                    case SequenceMethod.FirstOrDefault:
                        return query.AsEnumerable().FirstOrDefault();
#if !ASTORIA_LIGHT
                    case SequenceMethod.LongCount: 
                    case SequenceMethod.Count:
                        return (TElement)Convert.ChangeType(((DataServiceQuery)query).GetQuerySetCount(this.Context), typeof(TElement), System.Globalization.CultureInfo.InvariantCulture.NumberFormat); 
#endif 
                    default:
                        throw Error.MethodNotSupported(mce); 
                }
            }

            // Should never get here - should be caught by expression compiler. 
            Debug.Assert(false, "Not supported singleton operator not caught by Resource Binder");
            throw Error.MethodNotSupported(mce); 
        } 

        /// Builds the Uri for the expression passed in. 
        /// The expression to translate into a Uri
        /// Query components
        internal QueryComponents Translate(Expression e)
        { 
            Uri uri;
            Version version; 
            bool addTrailingParens = false; 
            Dictionary normalizerRewrites = null;
 
            // short cut analysis if just a resource set
            // note - to be backwards compatible with V1, will only append trailing () for queries
            // that include more then just a resource set.
            if (!(e is ResourceSetExpression)) 
            {
                normalizerRewrites = new Dictionary(ReferenceEqualityComparer.Instance); 
                e = Evaluator.PartialEval(e); 
                e = ExpressionNormalizer.Normalize(e, normalizerRewrites);
                e = ResourceBinder.Bind(e); 
                addTrailingParens = true;
            }

            UriWriter.Translate(this.Context, addTrailingParens, e, out uri, out version); 
            ResourceExpression re = e as ResourceExpression;
            Type lastSegmentType = re.Projection == null ? re.ResourceType : re.Projection.Selector.Parameters[0].Type; 
            LambdaExpression selector = re.Projection == null ? null : re.Projection.Selector; 
            return new QueryComponents(uri, version, lastSegmentType, selector, normalizerRewrites);
        } 
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK