Пример #1
0
        public override void Load(IEntityCollectionView <T> view)
        {
            lock (TimerLock)
            {
                if (Timer == null)
                {
                    Timer       = new DispatcherTimer();
                    Timer.Tick += (s, arg) =>
                    {
                        lock (TimerLock)
                        {
                            if (Timer != null)
                            {
                                Timer.Stop();
                                Timer = null;

                                LoadData(view);
                            }
                        }
                    };
                    Timer.Interval = RequestDelay;
                    Timer.Start();
                }
            }
        }
Пример #2
0
 public abstract void Load(IEntityCollectionView <T> view);
Пример #3
0
        private void LoadData(IEntityCollectionView <T> view)
        {
            #region query

            var requestId = ++RequestId;

            var query = Queryable.IncludeTotalCount();

            #endregion query

            #region paging

            if (view.PageSize > 0)
            {
                query = query
                        .Skip(view.PageIndex * view.PageSize)
                        .Take(view.PageSize);
            }

            #endregion pagging

            #region filters

            foreach (var filterExpression in view.FilterExpressions)
            {
                var remoteExpression = DataServiceQueryable.ToRemoteExpression(filterExpression);
                query = query.Where(remoteExpression);
            }

            #endregion filters

            #region sorting

            // apply sort descriptors
            IOrderedDataServiceQueryable <T, T> sortedQuery = null;
            foreach (var sortDescription in view.SortDescriptions)
            {
                var sortExpression = sortDescription.ToExpression <T>();
                if (ReferenceEquals(sortedQuery, null))
                {
                    sortedQuery = query.OrderBy(sortExpression);
                }
                else
                {
                    sortedQuery = sortedQuery.ThenBy(sortExpression);
                }
            }
            if (!ReferenceEquals(sortedQuery, null))
            {
                query = sortedQuery;
            }

            #endregion sorting

            #region request

            // notify data loading
            OnDataLoading();

            query.ExecuteAsync(
                (result) =>
            {
                if (requestId < RequestId)
                {
                    // request outdated
                    return;
                }

                // synchronize with main thread
                Dispatcher.BeginInvoke((Action) delegate
                {
                    // check for exception
                    if (result.IsFaulted)
                    {
                        var queryException = QueryException;
                        if (queryException != null)
                        {
                            queryException(this, new ExceptionEventArgs(result.Exception));
                            OnDataLoaded(null);
                            return;
                        }
                        else
                        {
                            throw new Exception("Query failed", result.Exception);
                        }
                    }

                    // retrieve data
                    var entitySet = result.EntitySet;

                    // fill items
                    view.Clear();
                    foreach (var item in entitySet)
                    {
                        view.Add(item);
                    }

                    // sets total count
                    view.TotalItemCount = entitySet.TotalCount.HasValue ? (int)entitySet.TotalCount.Value : -1;

                    // notify data loaded
                    OnDataLoaded(entitySet);
                });
            }
                );

            #endregion request
        }