/// <summary>
        /// Visits a property reference expression.
        /// </summary>
        /// <param name="expression">The expression to visit.</param>
        public override void VisitPropertyReferenceExpression(PropertyReferenceFilterExpression expression)
        {
            //This is working around a missing property on the filter api.
            //This could can be removed when the issue is resolved.
            ODataDataSourceFilterExpressionVisitor v = new ODataDataSourceFilterExpressionVisitor();

            v.VisitPropertyReferenceExpression(expression);
            string result = v.ToString();

            RenderPropertyReference(result);
        }
        protected override void MakeTaskForRequest(AsyncDataSourcePageRequest request, int retryDelay)
        {
            int actualPageSize = 0;
            SortDescriptionCollection sortDescriptions = null;
            lock (SyncLock)
            {
                actualPageSize = ActualPageSize;
                sortDescriptions = SortDescriptions;
            }

            ODataFeedAnnotations annotations = new ODataFeedAnnotations();

            var client = _client.For(_entitySet);

            lock (SyncLock)
            {
                if (FilterExpressions != null &&
                    FilterExpressions.Count > 0 &&
                    _filterString == null)
                {
                    StringBuilder sb = new StringBuilder();
                    bool first = true;
                    foreach (var expr in FilterExpressions)
                    {
                        if (first)
                        {
                            first = false;
                        }
                        else
                        {
                            sb.Append(" AND ");
                        }

                        ODataDataSourceFilterExpressionVisitor visitor = new ODataDataSourceFilterExpressionVisitor();

                        visitor.Visit(expr);

                        var txt = visitor.ToString();
                        if (FilterExpressions.Count > 1)
                        {
                            txt = "(" + txt + ")";
                        }
                        sb.Append(txt);
                    }
                    _filterString = sb.ToString();
                }

                if (_filterString != null)
                {
                    client = client.Filter(_filterString);
                }

                if (SortDescriptions != null)
                {
                    foreach (var sort in SortDescriptions)
                    {
                        if (sort.Direction == System.ComponentModel.ListSortDirection.Descending)
                        {
                            client = client.OrderByDescending(sort.PropertyName);
                        }
                        else
                        {
                            client = client.OrderBy(sort.PropertyName);
                        }
                    }
                }

                if (DesiredProperties != null && DesiredProperties.Length > 0)
                {
                    client = client.Select(DesiredProperties);   
                }
            }

            Task task;
            if (request.Index == SchemaRequestIndex)
            {
                task = client
                    .Count()
                    .FindScalarAsync<int>();
            }
            else
            {
                task = client
                    .Skip(request.Index * actualPageSize)
                    .Top(actualPageSize)
                    .FindEntriesAsync(annotations);
            }

            request.TaskHolder = new AsyncDataSourcePageTaskHolder();
            request.TaskHolder.Task = task;

            lock (SyncLock)
            {
                Tasks.Add(request);
                _annotations.Add(annotations);
            }
        }