/// <summary>
        /// Call by web home page a lot: priority 0
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public async Task <ItemInfo[]> GetAuctionItemsAsync(CancellationToken cancellationToken)
        {
            var qm = new FabricClient().QueryManager;
            // Get this service's partitions
            var partitions = await qm.GetPartitionListAsync(m_serviceNameUri, null, TimeSpan.FromSeconds(4), cancellationToken);

            // Get each partition's low key
            var partitionKeys = from partition in partitions
                                select((Int64RangePartitionInformation)partition.PartitionInformation).LowKey;

            // Simultaneously ask each partition for the auction items is has to sell
            var tasks = new List <Task <ItemInfo[]> >();

            foreach (var p in partitionKeys)
            {
                var resolver = m_partitionEndpointResolver.CreateSpecific(m_serviceNameUri.ToString(), p, c_endpointName);
                var proxy    = new InternetAuctionOperationProxy(resolver);
                tasks.Add(proxy.GetAuctionItemsAsync(cancellationToken));
            }

            // Continue processing after every partition's auction items have come in
            ItemInfo[][] partitionsItemInfos = await Task.WhenAll(tasks);

            // Combine them all together sorting them by expiration
            var results = (from partitionItemInfos in partitionsItemInfos
                           from itemInfo in partitionItemInfos
                           // where itemInfo.Expiration >= DateTime.UtcNow   // Change this for Version 2
                           orderby itemInfo.Expiration
                           select itemInfo).ToArray();

            return(results); // Return the set of auction items
        }
        private async Task <List <ActorInformation> > GetAllActors(Uri servicePath)
        {
            FabricClient.QueryClient query = new FabricClient().QueryManager;
            List <long> partitions         = new List <long>();
            string      continuation       = null;

            do
            {
                ServicePartitionList partitionList =
                    await query.GetPartitionListAsync(servicePath, continuation);

                foreach (Partition item in partitionList)
                {
                    ServicePartitionInformation info = item.PartitionInformation;
                    switch (info.Kind)
                    {
                    case ServicePartitionKind.Int64Range:
                        partitions.Add(((Int64RangePartitionInformation)info).LowKey);
                        break;

                    case ServicePartitionKind.Singleton:
                        partitions.Add(0L);
                        break;

                    default:
                        throw new InvalidOperationException(
                                  string.Format(
                                      "Unexpected partition kind.  Found {0}, expected either Int64Range or Singleton",
                                      info.Kind));
                    }
                }
                continuation = partitionList.ContinuationToken;
            } while (!string.IsNullOrEmpty(continuation));

            List <ActorInformation> activeActors = new List <ActorInformation>();

            foreach (long partitionId in partitions)
            {
                IActorService     actorServiceProxy = ActorServiceProxy.Create(servicePath, partitionId);
                ContinuationToken continuationToken = null;

                do
                {
                    PagedResult <ActorInformation> page =
                        await actorServiceProxy.GetActorsAsync(continuationToken, CancellationToken.None);

                    activeActors.AddRange(page.Items);
                    continuationToken = page.ContinuationToken;
                } while (continuationToken != null);
            }
            return(activeActors);
        }