internal VSSolutionManager(
IAsyncServiceProvider asyncServiceProvider,
IProjectSystemCache projectSystemCache,
NuGetProjectFactory projectSystemFactory,
ICredentialServiceProvider credentialServiceProvider,
IVsProjectAdapterProvider vsProjectAdapterProvider,
ILogger logger,
Lazy <ISettings> settings,
JoinableTaskContext joinableTaskContext)
{
Assumes.Present(asyncServiceProvider);
Assumes.Present(projectSystemCache);
Assumes.Present(projectSystemFactory);
Assumes.Present(credentialServiceProvider);
Assumes.Present(vsProjectAdapterProvider);
Assumes.Present(logger);
Assumes.Present(settings);
Assumes.Present(joinableTaskContext);
_asyncServiceProvider = asyncServiceProvider;
_projectSystemCache = projectSystemCache;
_projectSystemFactory = projectSystemFactory;
_credentialServiceProvider = credentialServiceProvider;
_vsProjectAdapterProvider = vsProjectAdapterProvider;
_logger = logger;
_settings = settings;
_initLock = new NuGetLockService(joinableTaskContext);
}
internal VSSolutionManager(
IAsyncServiceProvider asyncServiceProvider,
IProjectSystemCache projectSystemCache,
NuGetProjectFactory projectSystemFactory,
ICredentialServiceProvider credentialServiceProvider,
IVsProjectAdapterProvider vsProjectAdapterProvider,
ILogger logger,
Lazy <ISettings> settings,
INuGetFeatureFlagService featureFlagService,
JoinableTaskContext joinableTaskContext)
{
Assumes.Present(asyncServiceProvider);
Assumes.Present(projectSystemCache);
Assumes.Present(projectSystemFactory);
Assumes.Present(credentialServiceProvider);
Assumes.Present(vsProjectAdapterProvider);
Assumes.Present(logger);
Assumes.Present(settings);
Assumes.Present(featureFlagService);
Assumes.Present(joinableTaskContext);
_asyncServiceProvider = asyncServiceProvider;
_projectSystemCache = projectSystemCache;
_projectSystemFactory = projectSystemFactory;
_credentialServiceProvider = credentialServiceProvider;
_vsProjectAdapterProvider = vsProjectAdapterProvider;
_logger = logger;
_settings = settings;
_featureFlagService = featureFlagService;
_initLock = new NuGetLockService(joinableTaskContext);
_dte = new(() => asyncServiceProvider.GetDTEAsync(), NuGetUIThreadHelper.JoinableTaskFactory);
_asyncVSSolution = new(() => asyncServiceProvider.GetServiceAsync <SVsSolution, IVsSolution>(), NuGetUIThreadHelper.JoinableTaskFactory);
}
public PackageActionBaseCommand()
{
var componentModel = NuGetUIThreadHelper.JoinableTaskFactory.Run(ServiceLocator.GetComponentModelAsync);
_deleteOnRestartManager = componentModel.GetService <IDeleteOnRestartManager>();
_lockService = componentModel.GetService <INuGetLockService>();
}
internal VSSolutionManager(
[Import(typeof(SVsServiceProvider))]
IServiceProvider serviceProvider,
IProjectSystemCache projectSystemCache,
NuGetProjectFactory projectSystemFactory,
ICredentialServiceProvider credentialServiceProvider,
IVsProjectAdapterProvider vsProjectAdapterProvider,
[Import("VisualStudioActivityLogger")]
Common.ILogger logger,
Lazy <ISettings> settings,
JoinableTaskContext joinableTaskContext)
{
Assumes.Present(serviceProvider);
Assumes.Present(projectSystemCache);
Assumes.Present(projectSystemFactory);
Assumes.Present(credentialServiceProvider);
Assumes.Present(vsProjectAdapterProvider);
Assumes.Present(logger);
Assumes.Present(settings);
Assumes.Present(joinableTaskContext);
_serviceProvider = serviceProvider;
_projectSystemCache = projectSystemCache;
_projectSystemFactory = projectSystemFactory;
_credentialServiceProvider = credentialServiceProvider;
_vsProjectAdapterProvider = vsProjectAdapterProvider;
_logger = logger;
_settings = settings;
_initLock = new NuGetLockService(joinableTaskContext);
}
public static async Task <NuGetUI> CreateAsync(
IServiceBroker serviceBroker,
ICommonOperations commonOperations,
NuGetUIProjectContext projectContext,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
SolutionUserOptions solutionUserOptions,
INuGetLockService lockService,
INuGetUILogger logger,
IRestoreProgressReporter restoreProgressReporter,
CancellationToken cancellationToken,
params IProjectContextInfo[] projects)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(commonOperations);
Assumes.NotNull(projectContext);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(solutionUserOptions);
Assumes.NotNull(lockService);
Assumes.NotNull(restoreProgressReporter);
Assumes.NotNull(logger);
cancellationToken.ThrowIfCancellationRequested();
var nuGetUi = new NuGetUI(
commonOperations,
projectContext,
logger)
{
UIContext = await NuGetUIContext.CreateAsync(
serviceBroker,
sourceRepositoryProvider,
settings,
solutionManager,
packageRestoreManager,
optionsPageActivator,
solutionUserOptions,
deleteOnRestartManager,
lockService,
restoreProgressReporter,
cancellationToken)
};
nuGetUi.UIContext.Projects = projects;
return(nuGetUi);
}
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 packageManager = new NuGetPackageManager(
sourceRepositoryProvider,
settings,
solutionManager,
deleteOnRestartManager);
var actionEngine = new UIActionEngine(
sourceRepositoryProvider,
packageManager,
lockService);
return(new NuGetUIContext(
sourceRepositoryProvider,
serviceBroker,
solutionManager,
solutionManagerServiceWrapper,
packageManager,
actionEngine,
packageRestoreManager,
optionsPageActivator,
userSettingsManager,
packageManagerProviders));
}
/// <summary>
/// Create a UIActionEngine to perform installs/uninstalls
/// </summary>
public UIActionEngine(
ISourceRepositoryProvider sourceProvider,
NuGetPackageManager packageManager,
INuGetLockService lockService)
{
_sourceProvider = sourceProvider ?? throw new ArgumentNullException(nameof(sourceProvider));
_packageManager = packageManager ?? throw new ArgumentNullException(nameof(packageManager));
_lockService = lockService ?? throw new ArgumentNullException(nameof(lockService));
}
// A constructor utilized for running unit-tests
public SolutionRestoreBuildHandler(
INuGetLockService lockService,
ISettings settings,
ISolutionRestoreWorker restoreWorker,
IVsSolutionBuildManager3 buildManager)
{
Assumes.Present(lockService);
Assumes.Present(settings);
Assumes.Present(restoreWorker);
Assumes.Present(buildManager);
LockService = new Lazy <INuGetLockService>(() => lockService);
Settings = new Lazy <ISettings>(() => settings);
SolutionRestoreWorker = new Lazy <ISolutionRestoreWorker>(() => restoreWorker);
_solutionBuildManager = buildManager;
}
public PackageActionBaseCommand()
{
_deleteOnRestartManager = ServiceLocator.GetInstance <IDeleteOnRestartManager>();
_lockService = ServiceLocator.GetInstance <INuGetLockService>();
}
public UninstallPackageCommand()
{
_deleteOnRestartManager = ServiceLocator.GetComponentModelService <IDeleteOnRestartManager>();
_lockService = ServiceLocator.GetComponentModelService <INuGetLockService>();
}
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))
{
}
#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);
var actionEngine = new UIActionEngine(
sourceRepositoryProvider,
packageManager,
lockService);
return(new NuGetUIContext(
serviceBroker,
searchService.Object,
solutionManager,
solutionManagerServiceWrapper,
packageManager,
actionEngine,
packageRestoreManager,
optionsPageActivator,
userSettingsManager,
packageManagerProviders,
sourceServiceWrapper));
}
