public async ValueTask <ItemsProviderResult <Employee> > LoadEmployees(ItemsProviderRequest request)
{
var numberOfEmployees = Math.Min(request.Count, totalNumberOfEmployees - request.StartIndex);
var EmployeeListItems = await EmployeeDataService.GetTakeLongEmployeeList(request.StartIndex, numberOfEmployees);
return(new ItemsProviderResult <Employee>(EmployeeListItems, totalNumberOfEmployees));
}
private async ValueTask <ItemsProviderResult <TParent> > LoadItems(ItemsProviderRequest request)
{
var numItem = Math.Min(request.Count, TotalItemCount - request.StartIndex);
var items = await GetItems(request.StartIndex, numItem, request.CancellationToken);
return(new ItemsProviderResult <TParent>(items, TotalItemCount));
}
private async ValueTask <ItemsProviderResult <WeatherForecast> > LoadItems(ItemsProviderRequest request)
{
var numItems = Math.Min(request.Count, ItemsCount - request.StartIndex);
var items = forecasts.Skip(request.StartIndex).Take(numItems).ToList();
return(new ItemsProviderResult <WeatherForecast>(items, ItemsCount));
}
private async ValueTask <ItemsProviderResult <Employee> > LoadEmployees(ItemsProviderRequest request)
{
//assume we have asked the api for the total in a seperate call
var numberOfEmployees = Math.Min(request.Count, totalNumberOfEmployees - request.StartIndex);
var employees = await _employeeDataService.GetTakeLongEmployeeList(request.StartIndex, numberOfEmployees);
return(new ItemsProviderResult <Employee>(employees, totalNumberOfEmployees));
}
public async ValueTask <ItemsProviderResult <Employee> > LoadEmployees(ItemsProviderRequest request)
{
//assume that we have asked the API the total number in a separate call
var numberOfEmployees = Math.Min(request.Count, totalNumberOfEmployees - request.StartIndex);
var EmployeeListItems = await EmployeeDataService.GetTakeLongEmployeeList(request.StartIndex, numberOfEmployees);
return(new ItemsProviderResult <Employee>(EmployeeListItems, totalNumberOfEmployees));
}
private async ValueTask <ItemsProviderResult <Product> > LoadProducts(ItemsProviderRequest request)
{
var productNum = Math.Min(request.Count, TotalSize - request.StartIndex);
await OnScroll.InvokeAsync(new ProductParameters
{
StartIndex = request.StartIndex,
PageSize = productNum == 0 ? request.Count : productNum
});
return(new ItemsProviderResult <Product>(Products, TotalSize));
}
private async ValueTask <ItemsProviderResult <TItem> > LoadData(ItemsProviderRequest request)
{
loadPagedData();
int totalRows = 0;
if (pagedData != null)
{
totalRows = pagedData.Count();
}
var numberofItems = Math.Min(request.Count, totalRows - request.StartIndex);
return(new ItemsProviderResult <TItem>(pagedData.Skip(request.StartIndex).Take(numberofItems), totalRows));
}
public async ValueTask <ItemsProviderResult <Player> > GetPlayers(ItemsProviderRequest request)
{
IQueryable <Player> result = _context.Players
.ApplySophisticatedAiAlgorithm()
.OrderByDescending(x => x.ExtendNow)
.ThenBy(x => x.ExpiryDate)
.ThenBy(x => x.Id);
result = result.Skip(request.StartIndex)
.Take(request.Count);
return(new ItemsProviderResult <Player>(
await result.ToListAsync(),
await _context.Players.CountAsync()));
}
private async ValueTask <ItemsProviderResult <BugModel> > LoadBugs(ItemsProviderRequest request)
{
var req = request.StartIndex + request.Count;
if (req > BugsList.Count())
{
await LoadMoreBugs();
}
var list = FiltrList.Count == 0 ? BugsList : BugsList.Where(v => FiltrList.Contains(v.System)).ToList();
var totalCount = FiltrList.Count == 0 ? TotalCount : list.Count;
var bugs = list.Skip(request.StartIndex).Take(request.Count);
return(new ItemsProviderResult <BugModel>(bugs, totalCount));
}
private async ValueTask RefreshDataCoreAsync(bool renderOnSuccess)
{
_refreshCts?.Cancel();
CancellationToken cancellationToken;
if (_itemsProvider == DefaultItemsProvider)
{
// If we're using the DefaultItemsProvider (because the developer supplied a fixed
// Items collection) we know it will complete synchronously, and there's no point
// instantiating a new CancellationTokenSource
_refreshCts = null;
cancellationToken = CancellationToken.None;
}
else
{
_refreshCts = new CancellationTokenSource();
cancellationToken = _refreshCts.Token;
}
var request = new ItemsProviderRequest(_itemsBefore, _visibleItemCapacity, cancellationToken);
try
{
var result = await _itemsProvider(request);
// Only apply result if the task was not canceled.
if (!cancellationToken.IsCancellationRequested)
{
_itemCount = result.TotalItemCount;
_loadedItems = result.Items;
_loadedItemsStartIndex = request.StartIndex;
if (renderOnSuccess)
{
StateHasChanged();
}
}
}
catch (Exception e)
{
if (e is OperationCanceledException oce && oce.CancellationToken == cancellationToken)
{
// No-op; we canceled the operation, so it's fine to suppress this exception.
}
private ValueTask <ItemsProviderResult <TItem> > AlwaysThrowsItemsProvider <TItem>(ItemsProviderRequest request)
=> throw new InvalidOperationException("Thrown from items provider.");
private ValueTask <ItemsProviderResult <TItem> > EmptyItemsProvider <TItem>(ItemsProviderRequest request) => ValueTask.FromResult(new ItemsProviderResult <TItem>(Enumerable.Empty <TItem>(), 0));
public async ValueTask <ItemsProviderResult <Player> > GetPlayers(ItemsProviderRequest request)
{
var response = await _http.GetFromJsonAsync <PlayersResponse>($"/api/players?start={request.StartIndex}&count={request.Count}");
return(new ItemsProviderResult <Player>(response.Players, response.TotalCount));
}
private async ValueTask <ItemsProviderResult <MonitorStepLogDto> > LoadMonitorAsync(ItemsProviderRequest request)
{
var numStepLogs = Math.Min(request.Count, TotalMonitorStepLogCount - request.StartIndex);
Filter.SkipCount = request.StartIndex;
Filter.MaxResultCount = numStepLogs;
MonitorWithDetails = await MonitorAppService.GetAsync(Guid.Parse(Id), Filter);
return(new ItemsProviderResult <MonitorStepLogDto>(MonitorWithDetails.MonitorStep.MonitorStepLogs, TotalMonitorStepLogCount));
}
