private void RefreshAvailableUpdatesCount()
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_topPanel._labelUpgradeAvailable.Count = 0;
var loadContext = new PackageLoadContext(ActiveSources, Model.IsSolution, Model.Context);
var packageFeed = await CreatePackageFeedAsync(loadContext, ItemFilter.UpdatesAvailable, _uiLogger);
var loader = new PackageItemLoader(
loadContext, packageFeed, includePrerelease: IncludePrerelease);
// cancel previous refresh update count task, if any
// and start a new one.
var refreshCts = new CancellationTokenSource();
Interlocked.Exchange(ref _refreshCts, refreshCts)?.Cancel();
Model.CachedUpdates = new PackageSearchMetadataCache
{
Packages = await loader.GetAllPackagesAsync(refreshCts.Token),
IncludePrerelease = IncludePrerelease
};
_topPanel._labelUpgradeAvailable.Count = Model.CachedUpdates.Packages.Count;
});
}
/// <summary>
/// This method is called from several event handlers. So, consolidating the use of JTF.Run in this method
/// </summary>
private void SearchPackageInActivePackageSource(string searchText, bool useCache)
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var loadContext = new PackageLoadContext(ActiveSources, Model.IsSolution, Model.Context);
if (useCache)
{
loadContext.CachedPackages = Model.CachedUpdates;
}
;
var packageFeed = await CreatePackageFeedAsync(loadContext, _topPanel.Filter, _uiLogger);
var loader = new PackageItemLoader(
loadContext, packageFeed, searchText, IncludePrerelease);
var loadingMessage = string.IsNullOrWhiteSpace(searchText)
? Resx.Resources.Text_Loading
: string.Format(CultureInfo.CurrentCulture, Resx.Resources.Text_Searching, searchText);
_packageList.LoadItems(loader, loadingMessage, _uiLogger);
});
}
// For unit testing purposes
internal static async ValueTask <PackageItemLoader> CreateAsync(
IServiceBroker serviceBroker,
PackageLoadContext context,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
ContractItemFilter itemFilter,
IReconnectingNuGetSearchService searchService,
INuGetPackageFileService packageFileService,
string searchText = null,
bool includePrerelease = true,
bool useRecommender = false)
{
var itemLoader = new PackageItemLoader(
serviceBroker,
searchService,
context,
packageSources,
itemFilter,
searchText,
includePrerelease,
useRecommender);
await itemLoader.InitializeAsync(packageFileService);
return(itemLoader);
}
/// <summary>
/// This method is called from several event handlers. So, consolidating the use of JTF.Run in this method
/// </summary>
private void SearchPackagesAndRefreshUpdateCount(string searchText, bool useCache)
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var loadContext = new PackageLoadContext(ActiveSources, Model.IsSolution, Model.Context);
if (useCache)
{
loadContext.CachedPackages = Model.CachedUpdates;
}
;
var packageFeed = await CreatePackageFeedAsync(loadContext, _topPanel.Filter, _uiLogger);
var loader = new PackageItemLoader(
loadContext, packageFeed, searchText, IncludePrerelease);
var loadingMessage = string.IsNullOrWhiteSpace(searchText)
? Resx.Resources.Text_Loading
: string.Format(CultureInfo.CurrentCulture, Resx.Resources.Text_Searching, searchText);
// Set a new cancellation token source which will be used to cancel this task in case
// new loading task starts or manager ui is closed while loading packages.
_loadCts = new CancellationTokenSource();
// start SearchAsync task for initial loading of packages
var searchResultTask = loader.SearchAsync(continuationToken: null, cancellationToken: _loadCts.Token);
// this will wait for searchResultTask to complete instead of creating a new task
_packageList.LoadItems(loader, loadingMessage, _uiLogger, searchResultTask, _loadCts.Token);
// We only refresh update count, when we don't use cache so check it it's false
if (!useCache)
{
// clear existing caches
Model.CachedUpdates = null;
if (_topPanel.Filter.Equals(ItemFilter.UpdatesAvailable))
{
// it means selected tab is update itself, so just wait for searchAsyncTask to complete
// without making another call to loader to get all packages.
_topPanel._labelUpgradeAvailable.Count = 0;
var searchResult = await searchResultTask;
Model.CachedUpdates = new PackageSearchMetadataCache
{
Packages = searchResult.Items,
IncludePrerelease = IncludePrerelease
};
_topPanel._labelUpgradeAvailable.Count = Model.CachedUpdates.Packages.Count;
}
else
{
RefreshAvailableUpdatesCount();
}
}
});
}
private void RefreshConsolidatablePackagesCount()
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_topPanel._labelConsolidate.Count = 0;
var loadContext = new PackageLoadContext(ActiveSources, Model.IsSolution, Model.Context);
var packageFeed = await CreatePackageFeedAsync(loadContext, ItemFilter.Consolidate, _uiLogger);
var loader = new PackageItemLoader(
loadContext, packageFeed, includePrerelease: IncludePrerelease);
_topPanel._labelConsolidate.Count = await loader.GetTotalCountAsync(100, CancellationToken.None);
});
}
private void RefreshAvailableUpdatesCount()
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
_topPanel._labelUpgradeAvailable.Count = 0;
var loadContext = new PackageLoadContext(ActiveSources, Model.IsSolution, Model.Context);
var packageFeed = await CreatePackageFeedAsync(loadContext, ItemFilter.UpdatesAvailable, _uiLogger);
var loader = new PackageItemLoader(
loadContext, packageFeed, includePrerelease: IncludePrerelease);
Model.CachedUpdates = new PackageSearchMetadataCache
{
Packages = await loader.GetAllPackagesAsync(CancellationToken.None),
IncludePrerelease = IncludePrerelease
};
_topPanel._labelUpgradeAvailable.Count = Model.CachedUpdates.Packages.Count;
});
}