public void Swap_WhenNewServiceIsNull_ReturnsPreviousService()
{
using (INuGetSourcesService previousService = _wrapper.Swap(newService: null))
{
Assert.NotNull(previousService);
}
}
private void PackageSourcesOptionsControl_Disposed(object sender, EventArgs e)
{
Disposed -= PackageSourcesOptionsControl_Disposed;
_nugetSourcesService?.Dispose();
_nugetSourcesService = null;
_packageSources?.Dispose();
_machineWidepackageSources?.Dispose();
}
public void Swap_WhenNewServiceIsNonNull_ReturnsPreviousService()
{
using (INuGetSourcesService expectedResult = _wrapper.Service)
using (INuGetSourcesService actualResult = _wrapper.Swap(new TestNuGetSourcesService()))
{
Assert.Same(expectedResult, actualResult);
}
}
/// <summary>
/// This gets called when users close the Options dialog
/// </summary>
internal void ClearSettings()
{
// clear this flag so that we will set up the bindings again when the option page is activated next time
_initialized = false;
_nugetSourcesService?.Dispose();
_nugetSourcesService = null;
_packageSources = null;
ClearNameSource();
UpdateUI();
}
public void Dispose()
{
lock (_syncObject)
{
using (INuGetSourcesService? service = _service)
{
_service = NullNuGetSourcesService.Instance;
}
}
GC.SuppressFinalize(this);
}
private static async ValueTask <INuGetSourcesService> GetSourceServiceAsync(
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
#pragma warning disable ISB001 // Dispose of proxies
INuGetSourcesService sourceService = await serviceBroker.GetProxyAsync <INuGetSourcesService>(
NuGetServices.SourceProviderService,
cancellationToken);
#pragma warning restore ISB001 // Dispose of proxies
Assumes.NotNull(sourceService);
return(sourceService);
}
public INuGetSourcesService Swap(INuGetSourcesService newService)
{
lock (_syncObject)
{
Service.PackageSourcesChanged -= OnPackageSourcesChanged;
INuGetSourcesService oldService = _service;
_service = newService ?? NullNuGetSourcesService.Instance;
Service.PackageSourcesChanged += OnPackageSourcesChanged;
return(oldService);
}
}
public static async ValueTask <IReadOnlyCollection <PackageSourceMoniker> > PopulateListAsync(
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
Assumes.NotNull(serviceBroker);
using (INuGetSourcesService nugetSourcesService = await serviceBroker.GetProxyAsync <INuGetSourcesService>(
NuGetServices.SourceProviderService,
cancellationToken))
{
Assumes.NotNull(nugetSourcesService);
IReadOnlyList <PackageSourceContextInfo> packageSources = await nugetSourcesService.GetPackageSourcesAsync(cancellationToken);
return(await PopulateListAsync(packageSources, cancellationToken));
}
}
private void OnAvailabilityChanged(object sender, BrokeredServicesChangedEventArgs e)
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
INuGetSolutionManagerService newService = await GetSolutionManagerServiceAsync(
ServiceBroker,
CancellationToken.None);
using (_solutionManagerService.Swap(newService))
{
}
INuGetSourcesService newSourceService = await GetSourceServiceAsync(
ServiceBroker,
CancellationToken.None);
using (_sourceService.Swap(newSourceService))
{
}
})
.PostOnFailure(nameof(NuGetUIContext), nameof(OnAvailabilityChanged));
}
internal async Task InitializeOnActivatedAsync(CancellationToken cancellationToken)
{
try
{
if (_initialized)
{
return;
}
_initialized = true;
IServiceBrokerProvider serviceBrokerProvider = await ServiceLocator.GetComponentModelServiceAsync <IServiceBrokerProvider>();
IServiceBroker serviceBroker = await serviceBrokerProvider.GetAsync();
#pragma warning disable ISB001 // Dispose of proxies, disposed in disposing event or in ClearSettings
_nugetSourcesService = await serviceBroker.GetProxyAsync <INuGetSourcesService>(
NuGetServices.SourceProviderService,
cancellationToken : cancellationToken);
#pragma warning restore ISB001 // Dispose of proxies, disposed in disposing event or in ClearSettings
Assumes.NotNull(_nugetSourcesService);
// get packages sources
_originalPackageSources = await _nugetSourcesService.GetPackageSourcesAsync(cancellationToken);
// packageSources and machineWidePackageSources are deep cloned when created, no need to worry about re-querying for sources to diff changes
var allPackageSources = _originalPackageSources;
var packageSources = allPackageSources.Where(ps => !ps.IsMachineWide).ToList();
var machineWidePackageSources = allPackageSources.Where(ps => ps.IsMachineWide).ToList();
// bind to the package sources, excluding Aggregate
_packageSources = new BindingSource(packageSources.Select(ps => ps.Clone()).ToList(), null);
_packageSources.CurrentChanged += OnSelectedPackageSourceChanged;
PackageSourcesListBox.GotFocus += PackageSourcesListBox_GotFocus;
PackageSourcesListBox.DataSource = _packageSources;
ResetItemsCheckedState(PackageSourcesListBox, _packageSources);
if (machineWidePackageSources.Count > 0)
{
_machineWidepackageSources = new BindingSource(machineWidePackageSources.Select(ps => ps.Clone()).ToList(), null);
_machineWidepackageSources.CurrentChanged += OnSelectedMachineWidePackageSourceChanged;
MachineWidePackageSourcesListBox.GotFocus += MachineWidePackageSourcesListBox_GotFocus;
MachineWidePackageSourcesListBox.DataSource = _machineWidepackageSources;
ResetItemsCheckedState(MachineWidePackageSourcesListBox, _machineWidepackageSources);
}
else
{
MachineWidePackageSourcesListBox.Visible = MachineWideSourcesLabel.Visible = false;
}
OnSelectedPackageSourceChanged(null, EventArgs.Empty);
}
// Thrown during creating or saving NuGet.Config.
catch (NuGetConfigurationException ex)
{
MessageHelper.ShowErrorMessage(ex.Message, Resources.ErrorDialogBoxTitle);
}
// Thrown if no nuget.config found.
catch (InvalidOperationException ex)
{
MessageHelper.ShowErrorMessage(ex.Message, Resources.ErrorDialogBoxTitle);
}
catch (UnauthorizedAccessException)
{
MessageHelper.ShowErrorMessage(Resources.ShowError_ConfigUnauthorizedAccess, Resources.ErrorDialogBoxTitle);
}
// Unknown exception.
catch (Exception ex)
{
MessageHelper.ShowErrorMessage(Resources.ShowError_SettingActivatedFailed, Resources.ErrorDialogBoxTitle);
ActivityLog.LogError(NuGetUI.LogEntrySource, ex.ToString());
}
}
public static async ValueTask <NuGetUIContext> CreateAsync(
IServiceBroker serviceBroker,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
IEnumerable <IVsPackageManagerProvider> packageManagerProviders,
INuGetLockService lockService,
CancellationToken cancellationToken)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(packageManagerProviders);
Assumes.NotNull(lockService);
cancellationToken.ThrowIfCancellationRequested();
var solutionManagerServiceWrapper = new NuGetSolutionManagerServiceWrapper();
INuGetSolutionManagerService solutionManagerService = await GetSolutionManagerServiceAsync(serviceBroker, cancellationToken);
// The initial Swap(...) should return a null implementation of the interface that does not require disposal.
// However, there's no harm in following form.
using (solutionManagerServiceWrapper.Swap(solutionManagerService))
{
}
var sourceServiceWrapper = new NuGetSourcesServiceWrapper();
INuGetSourcesService sourceService = await GetSourceServiceAsync(serviceBroker, cancellationToken);
using (sourceServiceWrapper.Swap(sourceService))
{
}
var packageManager = new NuGetPackageManager(
sourceRepositoryProvider,
settings,
solutionManager,
deleteOnRestartManager);
var actionEngine = new UIActionEngine(
sourceRepositoryProvider,
packageManager,
lockService);
return(new NuGetUIContext(
serviceBroker,
solutionManager,
solutionManagerServiceWrapper,
packageManager,
actionEngine,
packageRestoreManager,
optionsPageActivator,
userSettingsManager,
packageManagerProviders,
sourceServiceWrapper));
}
public static async ValueTask <NuGetUIContext> CreateAsync(
IServiceBroker serviceBroker,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
INuGetLockService lockService,
IRestoreProgressReporter restoreProgressReporter,
CancellationToken cancellationToken)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(lockService);
Assumes.NotNull(restoreProgressReporter);
cancellationToken.ThrowIfCancellationRequested();
var solutionManagerServiceWrapper = new NuGetSolutionManagerServiceWrapper();
INuGetSolutionManagerService solutionManagerService = await GetSolutionManagerServiceAsync(serviceBroker, cancellationToken);
// The initial Swap(...) should return a null implementation of the interface that does not require disposal.
// However, there's no harm in following form.
using (solutionManagerServiceWrapper.Swap(solutionManagerService))
{
}
var sourceServiceWrapper = new NuGetSourcesServiceWrapper();
INuGetSourcesService sourceService = await GetSourceServiceAsync(serviceBroker, cancellationToken);
using (sourceServiceWrapper.Swap(sourceService))
{
}
#pragma warning disable CA2000 // Dispose objects before losing scope - NuGetUIContext owns the instance and should dispose it.
var searchService = await NuGetSearchServiceReconnector.CreateAsync(serviceBroker, NuGetUIThreadHelper.JoinableTaskFactory, cancellationToken);
#pragma warning restore CA2000 // Dispose objects before losing scope
var packageManager = new NuGetPackageManager(
sourceRepositoryProvider,
settings,
solutionManager,
deleteOnRestartManager,
restoreProgressReporter);
var actionEngine = new UIActionEngine(
sourceRepositoryProvider,
packageManager,
lockService);
return(new NuGetUIContext(
serviceBroker,
searchService.Object,
solutionManager,
solutionManagerServiceWrapper,
packageManager,
actionEngine,
packageRestoreManager,
optionsPageActivator,
userSettingsManager,
sourceServiceWrapper));
}
