private CachedDataViewState GetCacheState(CollectionQuery query)
{
var lastIndexRequested = query.Skip + query.Take - 1;
CachedDataSet cachedItems;
if (cachedData.TryGetValue(query.CacheKey, out cachedItems) == false)
{
return(CachedDataViewState.CompleteMiss);
}
else if (lastIndexRequested < cachedItems.Items.Count)
{
return(CachedDataViewState.CompleteHit);
}
else if (query.Skip < cachedItems.Items.Count && cachedItems.IsComplete == false)
{
return(CachedDataViewState.PartialHit);
}
else if (cachedItems.IsComplete)
{
return(CachedDataViewState.CompleteHit);
}
else
{
return(CachedDataViewState.CompleteMiss);
}
}
private bool IsEndOfCache(CollectionQuery query)
{
CachedDataSet cachedItems;
if (cachedData.TryGetValue(query.CacheKey, out cachedItems) == false)
{
return(false);
}
var cacheState = GetCacheState(query);
if (cacheState == CachedDataViewState.CompleteMiss)
{
return(false);
}
else if (cacheState == CachedDataViewState.PartialHit)
{
return(true);
}
else if (cachedItems.Items.Count < query.Take && cachedItems.IsComplete)
{
return(true);
}
else
{
return(cachedItems.Items.Count - query.Take == query.Skip);
}
}
protected override async Task<LoadMoreResult> LoadMoreAsync(CollectionQuery query, object continuationToken)
{
var next = await client.ListContainersSegmentedAsync(continuationToken as BlobContinuationToken);
var result = new LoadMoreResult(next.Results.Where
(r =>
query.Filter == null ||
(r.Name.IndexOf(query.Filter,StringComparison.InvariantCultureIgnoreCase) >= 0)
).Select(r => new ContainerRecord(r) as object).ToList(), next.ContinuationToken);
return result;
}
public bool HasAllDataBeenLoaded(CollectionQuery query)
{
CachedDataSet dataSet;
if (cachedData.TryGetValue(query.CacheKey, out dataSet) == false)
{
return(false);
}
return(dataSet.IsComplete);
}
protected override async Task<LoadMoreResult> LoadMoreAsync(CollectionQuery query, object continuationToken)
{
BlobResultSegment next;
next = await container.ListBlobsSegmentedAsync(query.Filter, true, BlobListingDetails.All, null, (continuationToken as BlobContinuationToken), new BlobRequestOptions(), new Microsoft.WindowsAzure.Storage.OperationContext());
var result = new LoadMoreResult(next.Results.Select(r => r as object).ToList(), next.ContinuationToken );
return result;
}
public override CollectionDataView GetDataView(CollectionQuery query)
{
lock (cachedData)
{
var cacheState = GetCacheState(query);
if (cacheState != CachedDataViewState.CompleteHit && isLoading == false && HasAllDataBeenLoaded(query) == false)
{
isLoading = true;
pump.QueueAsyncAction(LoadMoreAsync(query, lastContinuationToken), (t) =>
{
if (t.Exception != null)
{
throw new AggregateException(t.Exception);
}
lock (cachedData)
{
CachedDataSet results;
if (cachedData.TryGetValue(query.CacheKey, out results) == false)
{
results = new CachedDataSet();
results.Items.AddRange(t.Result.Items);
cachedData.Add(query.CacheKey, results);
}
else
{
results.Items.AddRange(t.Result.Items);
}
if (t.Result.ContinuationToken == null)
{
results.IsComplete = true;
}
}
lastContinuationToken = t.Result.ContinuationToken;
isLoading = false;
FireDataChanged();
});
}
if (cacheState == CachedDataViewState.CompleteHit)
{
return(CreateFromCache(query, true, HasAllDataBeenLoaded(query) && IsEndOfCache(query)));
}
else if (cacheState == CachedDataViewState.CompleteMiss)
{
return(new CollectionDataView(new List <object>(), HasAllDataBeenLoaded(query), HasAllDataBeenLoaded(query), query.Skip));
}
else
{
return(CreateFromCache(query, HasAllDataBeenLoaded(query), HasAllDataBeenLoaded(query)));
}
}
}
public override int GetHighestKnownIndex(CollectionQuery query)
{
IEnumerable <object> results = Items;
if (query.Filter != null)
{
results = results.Where(item => MatchesFilter(item, query.Filter));
}
return(results.Count() - 1);
}
public override int GetHighestKnownIndex(CollectionQuery query)
{
IEnumerable<object> results = Items;
if (query.Filter != null)
{
results = results.Where(item => MatchesFilter(item, query.Filter));
}
return results.Count() - 1;
}
public override int GetHighestKnownIndex(CollectionQuery query)
{
if (cachedData.ContainsKey(query.CacheKey))
{
return(cachedData[query.CacheKey].Items.Count - 1);
}
else
{
return(0);
}
}
public override CollectionDataView GetDataView(CollectionQuery query)
{
lock(cachedData)
{
var cacheState = GetCacheState(query);
if (cacheState != CachedDataViewState.CompleteHit && isLoading == false && HasAllDataBeenLoaded(query) == false)
{
isLoading = true;
pump.QueueAsyncAction(LoadMoreAsync(query, lastContinuationToken), (t) =>
{
if (t.Exception != null) throw new AggregateException(t.Exception);
lock (cachedData)
{
CachedDataSet results;
if (cachedData.TryGetValue(query.CacheKey, out results) == false)
{
results = new CachedDataSet();
results.Items.AddRange(t.Result.Items);
cachedData.Add(query.CacheKey, results);
}
else
{
results.Items.AddRange(t.Result.Items);
}
if (t.Result.ContinuationToken == null)
{
results.IsComplete = true;
}
}
lastContinuationToken = t.Result.ContinuationToken;
isLoading = false;
FireDataChanged();
});
}
if (cacheState == CachedDataViewState.CompleteHit)
{
return CreateFromCache(query, true, HasAllDataBeenLoaded(query) && IsEndOfCache(query));
}
else if (cacheState == CachedDataViewState.CompleteMiss)
{
return new CollectionDataView(new List<object>(), HasAllDataBeenLoaded(query), HasAllDataBeenLoaded(query), query.Skip);
}
else
{
return CreateFromCache(query, HasAllDataBeenLoaded(query), HasAllDataBeenLoaded(query));
}
}
}
protected override async Task<LoadMoreResult> LoadMoreAsync(CollectionQuery query, object continuationToken)
{
var tableQuery = new TableQuery();
tableQuery.FilterString = query.Filter;
try
{
var next = await table.ExecuteQuerySegmentedAsync(tableQuery, continuationToken as TableContinuationToken);
var result = new LoadMoreResult(next.Results.Select(r => r as object).ToList(), next.ContinuationToken);
return result;
}
catch (StorageException ex)
{
var result = new LoadMoreResult(new List<object>(), null);
return result;
}
}
private void InitGridViewModel()
{
this.SelectionMode = GridSelectionMode.Row;
this.RowPrefix = ConsoleString.Empty;
this.Gutter = 3;
this.VisibleColumns = new ObservableCollection <ColumnViewModel>();
visibleRowOffset = 0;
SelectedIndex = 0;
dataSourceSub = SubscribeUnmanaged(nameof(DataSource), DataSourceOrBoundsChangedListener);
boundsSub = SubscribeUnmanaged(nameof(Bounds), DataSourceOrBoundsChangedListener);
this.query = new CollectionQuery();
this.NoDataMessage = "No data";
this.EndOfDataMessage = "End";
this.NoVisibleColumnsMessage = "No visible columns";
}
public override CollectionDataView GetDataView(CollectionQuery query)
{
IEnumerable <object> results = Items;
if (query.Filter != null)
{
results = results.Where(item => MatchesFilter(item, query.Filter));
}
results = results.Skip(query.Skip).Take(query.Take);
foreach (var orderBy in query.SortOrder)
{
if (results is IOrderedEnumerable <object> )
{
if (orderBy.Descending)
{
results = (results as IOrderedEnumerable <object>).ThenByDescending(item => item?.GetType().GetProperty(orderBy.Value).GetValue(item));
}
else
{
results = (results as IOrderedEnumerable <object>).ThenBy(item => item?.GetType().GetProperty(orderBy.Value).GetValue(item));
}
}
else
{
if (orderBy.Descending)
{
results = results.OrderByDescending(item => item?.GetType().GetProperty(orderBy.Value).GetValue(item));
}
else
{
results = results.OrderBy(item => item?.GetType().GetProperty(orderBy.Value).GetValue(item));
}
}
}
return(new CollectionDataView(results.ToList(), true, query.Skip + query.Take >= Items.Where(item => MatchesFilter(item, query.Filter)).Count() - 1, query.Skip));
}
public override CollectionDataView GetDataView(CollectionQuery query)
{
IEnumerable<object> results = Items;
if (query.Filter != null)
{
results = results.Where(item => MatchesFilter(item, query.Filter));
}
results = results.Skip(query.Skip).Take(query.Take);
foreach (var orderBy in query.SortOrder)
{
if (results is IOrderedEnumerable<object>)
{
if (orderBy.Descending)
{
results = (results as IOrderedEnumerable<object>).ThenByDescending(item => item?.GetType().GetProperty(orderBy.Value).GetValue(item));
}
else
{
results = (results as IOrderedEnumerable<object>).ThenBy(item => item?.GetType().GetProperty(orderBy.Value).GetValue(item));
}
}
else
{
if (orderBy.Descending)
{
results = results.OrderByDescending(item => item?.GetType().GetProperty(orderBy.Value).GetValue(item));
}
else
{
results = results.OrderBy(item => item?.GetType().GetProperty(orderBy.Value).GetValue(item));
}
}
}
return new CollectionDataView(results.ToList(), true, query.Skip + query.Take >= Items.Where(item => MatchesFilter(item, query.Filter)).Count() - 1, query.Skip);
}
private CollectionDataView CreateFromCache(CollectionQuery query, bool cachedPageIsComplete, bool isEndOfData)
{
var results = cachedData[query.CacheKey].Items.Skip(query.Skip).Take(query.Take);
return new CollectionDataView(results.ToList(),cachedPageIsComplete,isEndOfData, query.Skip);
}
public abstract int GetHighestKnownIndex(CollectionQuery query);
protected abstract Task <LoadMoreResult> LoadMoreAsync(CollectionQuery query, object continuationToken);
private CollectionDataView CreateFromCache(CollectionQuery query, bool cachedPageIsComplete, bool isEndOfData)
{
var results = cachedData[query.CacheKey].Items.Skip(query.Skip).Take(query.Take);
return(new CollectionDataView(results.ToList(), cachedPageIsComplete, isEndOfData, query.Skip));
}
public abstract int GetHighestKnownIndex(CollectionQuery query);
protected override async Task<LoadMoreResult> LoadMoreAsync(CollectionQuery query, object continuationToken)
{
var next = await client.ListTablesSegmentedAsync(query.Filter, continuationToken as TableContinuationToken);
var result = new LoadMoreResult(next.Results.Select(r => r as object).ToList(), next.ContinuationToken);
return result;
}
protected override Task<LoadMoreResult> LoadMoreAsync(CollectionQuery query, object continuationToken)
{
return Task.Factory.StartNew(() =>
{
int index = continuationToken == null ? 0 : int.Parse(continuationToken as string);
// sleep to simulate a delay in the async code
Thread.Sleep(rand.Next((int)MaxDelay.TotalMilliseconds / 2, (int)MaxDelay.TotalMilliseconds));
List<object> batch = new List<object>();
while (batch.Count < LoadBatchSize && index < serverData.Count)
{
if (query.Filter == null || serverData[index].Value.IndexOf(query.Filter, StringComparison.InvariantCultureIgnoreCase) >= 0)
{
batch.Add(serverData[index]);
}
index++;
}
foreach (var item in batch)
{
Assert.IsNotNull(item);
}
var ret = new LoadMoreResult(batch, batch.Count == 0 ? null : index < serverData.Count ? index + "" : null);
return ret;
});
}
public abstract CollectionDataView GetDataView(CollectionQuery query);
private bool IsEndOfCache(CollectionQuery query)
{
CachedDataSet cachedItems;
if (cachedData.TryGetValue(query.CacheKey, out cachedItems) == false)
{
return false;
}
var cacheState = GetCacheState(query);
if (cacheState == CachedDataViewState.CompleteMiss) return false;
else if (cacheState == CachedDataViewState.PartialHit) return true;
else
{
return query.Skip + query.Take >= cachedItems.Items.Count;
}
}
public abstract CollectionDataView GetDataView(CollectionQuery query);
protected abstract Task<LoadMoreResult> LoadMoreAsync(CollectionQuery query, object continuationToken);
private void InitGridViewModel()
{
this.SelectionMode = GridSelectionMode.Row;
this.RowPrefix = ConsoleString.Empty;
this.Gutter = 3;
this.VisibleColumns = new ObservableCollection<ColumnViewModel>();
visibleRowOffset = 0;
SelectedIndex = 0;
dataSourceSub = SubscribeUnmanaged(nameof(DataSource), DataSourceOrBoundsChangedListener);
boundsSub = SubscribeUnmanaged(nameof(Bounds), DataSourceOrBoundsChangedListener);
this.query = new CollectionQuery();
this.NoDataMessage = "No data";
this.EndOfDataMessage = "End";
this.NoVisibleColumnsMessage = "No visible columns";
}
public override int GetHighestKnownIndex(CollectionQuery query)
{
if(cachedData.ContainsKey(query.CacheKey))
{
return cachedData[query.CacheKey].Items.Count - 1;
}
else
{
return 0;
}
}
public void LoadMoreBasic()
{
int expectedNumberOfItems = 95;
CliMessagePump pump = new CliMessagePump(ConsoleProvider.Current);
TestLoadMoreDataSource dataSource = new TestLoadMoreDataSource(pump, expectedNumberOfItems, TimeSpan.FromMilliseconds(50));
var query = new CollectionQuery(0, 7, null);
List<object> viewedData = new List<object>();
var pumpTask = pump.Start();
try
{
// make sure the pump has started up
Thread.Sleep(20);
// the first call to GetDataView should return an empty result that indicates that the view is incomplete
// because it is still loading data
var initialDataView = dataSource.GetDataView(query);
Assert.IsFalse(initialDataView.IsViewComplete);
Assert.IsFalse(initialDataView.IsViewEndOfData);
Assert.AreEqual(0, initialDataView.Items.Count);
// Since we're simulating the server call and we know the max amount of time it can take wait twice that long
Thread.Sleep(dataSource.MaxDelay + dataSource.MaxDelay);
// Now there should be a full page of data available to us
var nextAttemptDataView = dataSource.GetDataView(query);
Assert.AreEqual(query.Take, nextAttemptDataView.Items.Count);
Assert.IsTrue(nextAttemptDataView.IsViewComplete);
Assert.IsFalse(nextAttemptDataView.IsViewEndOfData);
viewedData.AddRange(nextAttemptDataView.Items);
query.Skip += query.Take;
// now ask for data in a tight loop. Sometimes we will get more data, sometimes we'll get an empty page
// while more data is being loaded
while (nextAttemptDataView.IsViewEndOfData == false)
{
nextAttemptDataView = dataSource.GetDataView(query);
Console.WriteLine(nextAttemptDataView.Items.Count + " items, viewComplete == " + nextAttemptDataView.IsViewComplete);
if (nextAttemptDataView.Items.Count < query.Take && nextAttemptDataView.IsViewEndOfData == false)
{
Thread.Sleep(10);
Assert.IsFalse(nextAttemptDataView.IsViewComplete);
}
else if (nextAttemptDataView.Items.Count == query.Take)
{
Assert.IsTrue(nextAttemptDataView.IsViewComplete);
}
else if (nextAttemptDataView.Items.Count > query.Take)
{
Assert.Fail(nextAttemptDataView.Items.Count + " should never exceed " + query.Take);
}
viewedData.AddRange(nextAttemptDataView.Items);
query.Skip += nextAttemptDataView.Items.Count;
}
int nextExpectedId = 0;
foreach (var item in viewedData)
{
Assert.IsNotNull(item);
Console.WriteLine(item);
Assert.AreEqual(nextExpectedId++, ((Item)item).Id);
}
Assert.AreEqual(expectedNumberOfItems, viewedData.Count);
console.Input.Enqueue(new ConsoleKeyInfo(' ', ConsoleKey.Escape, false, false, false));
} finally
{
pump.Stop();
pumpTask.Wait();
}
}
public bool HasAllDataBeenLoaded(CollectionQuery query)
{
CachedDataSet dataSet;
if(cachedData.TryGetValue(query.CacheKey, out dataSet) == false)
{
return false;
}
return dataSet.IsComplete;
}
private CachedDataViewState GetCacheState(CollectionQuery query)
{
var lastIndexRequested = query.Skip + query.Take- 1;
CachedDataSet cachedItems;
if(cachedData.TryGetValue(query.CacheKey, out cachedItems) == false)
{
return CachedDataViewState.CompleteMiss;
}
else if(lastIndexRequested < cachedItems.Items.Count)
{
return CachedDataViewState.CompleteHit;
}
else if(query.Skip < cachedItems.Items.Count && cachedItems.IsComplete == false)
{
return CachedDataViewState.PartialHit;
}
else if(cachedItems.IsComplete)
{
return CachedDataViewState.CompleteHit;
}
else
{
return CachedDataViewState.CompleteMiss;
}
}
