public CpsPackageReferenceProject(
string projectName,
string projectUniqueName,
string projectFullPath,
IProjectSystemCache projectSystemCache,
UnconfiguredProject unconfiguredProject,
INuGetProjectServices projectServices,
string projectId)
: base(projectName,
projectUniqueName,
projectFullPath)
{
Assumes.Present(projectFullPath);
Assumes.Present(projectSystemCache);
Assumes.Present(projectServices);
ProjectStyle = ProjectStyle.PackageReference;
_projectSystemCache = projectSystemCache;
_unconfiguredProject = unconfiguredProject;
ProjectServices = projectServices;
InternalMetadata.Add(NuGetProjectMetadataKeys.Name, ProjectName);
InternalMetadata.Add(NuGetProjectMetadataKeys.UniqueName, ProjectUniqueName);
InternalMetadata.Add(NuGetProjectMetadataKeys.FullPath, ProjectFullPath);
InternalMetadata.Add(NuGetProjectMetadataKeys.ProjectId, projectId);
}
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);
}
/// <summary>
/// Tries to get the projectId for a project from the project system cache using the project unique name.
/// </summary>
/// <param name="projectUniqueName">Unique name for the project.</param>
/// <param name="cache">ProjectSystem cache</param>
/// <param name="result">Contains the projectId if the return result was true else it is set to null.</param>
/// <returns>Returns bool indicating if the operation was successful.</returns>
private static bool TryGetProjectIdFromCache(string projectUniqueName, IProjectSystemCache cache, out string result)
{
result = null;
return(cache.TryGetNuGetProject(projectUniqueName, out var cacheEntry) &&
cacheEntry.TryGetMetadata(NuGetProjectMetadataKeys.ProjectId, out result));
}
public CpsPackageReferenceProject(
string projectName,
string projectUniqueName,
string projectFullPath,
IProjectSystemCache projectSystemCache,
EnvDTEProject envDTEProject,
UnconfiguredProject unconfiguredProject,
string projectId)
{
if (projectFullPath == null)
{
throw new ArgumentNullException(nameof(projectFullPath));
}
if (projectSystemCache == null)
{
throw new ArgumentNullException(nameof(projectSystemCache));
}
_projectName = projectName;
_projectUniqueName = projectUniqueName;
_projectFullPath = projectFullPath;
_projectSystemCache = projectSystemCache;
_envDTEProject = envDTEProject;
_unconfiguredProject = unconfiguredProject;
InternalMetadata.Add(NuGetProjectMetadataKeys.Name, _projectName);
InternalMetadata.Add(NuGetProjectMetadataKeys.UniqueName, _projectUniqueName);
InternalMetadata.Add(NuGetProjectMetadataKeys.FullPath, _projectFullPath);
InternalMetadata.Add(NuGetProjectMetadataKeys.ProjectId, projectId);
}
public NetCorePackageReferenceProject(
string projectName,
string projectUniqueName,
string projectFullPath,
IProjectSystemCache projectSystemCache,
IVsProjectAdapter vsProjectAdapter,
UnconfiguredProject unconfiguredProject,
string projectId)
{
if (projectFullPath == null)
{
throw new ArgumentNullException(nameof(projectFullPath));
}
if (projectSystemCache == null)
{
throw new ArgumentNullException(nameof(projectSystemCache));
}
_projectName = projectName;
_projectUniqueName = projectUniqueName;
_projectFullPath = projectFullPath;
ProjectStyle = ProjectStyle.PackageReference;
_projectSystemCache = projectSystemCache;
_vsProjectAdapter = vsProjectAdapter;
_unconfiguredProject = unconfiguredProject;
InternalMetadata.Add(NuGetProjectMetadataKeys.Name, _projectName);
InternalMetadata.Add(NuGetProjectMetadataKeys.UniqueName, _projectUniqueName);
InternalMetadata.Add(NuGetProjectMetadataKeys.FullPath, _projectFullPath);
InternalMetadata.Add(NuGetProjectMetadataKeys.ProjectId, projectId);
}
public NetCorePackageReferenceProject(
string projectName,
string projectUniqueName,
string projectFullPath,
IProjectSystemCache projectSystemCache,
IVsProjectAdapter vsProjectAdapter,
UnconfiguredProject unconfiguredProject,
INuGetProjectServices projectServices,
string projectId)
{
Assumes.Present(projectFullPath);
Assumes.Present(projectSystemCache);
Assumes.Present(projectServices);
_projectName = projectName;
_projectUniqueName = projectUniqueName;
_projectFullPath = projectFullPath;
ProjectStyle = ProjectStyle.PackageReference;
_projectSystemCache = projectSystemCache;
_vsProjectAdapter = vsProjectAdapter;
_unconfiguredProject = unconfiguredProject;
ProjectServices = projectServices;
InternalMetadata.Add(NuGetProjectMetadataKeys.Name, _projectName);
InternalMetadata.Add(NuGetProjectMetadataKeys.UniqueName, _projectUniqueName);
InternalMetadata.Add(NuGetProjectMetadataKeys.FullPath, _projectFullPath);
InternalMetadata.Add(NuGetProjectMetadataKeys.ProjectId, projectId);
}
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);
}
public VsSolutionRestoreService(
IProjectSystemCache projectSystemCache,
ISolutionRestoreWorker restoreWorker,
[Import("VisualStudioActivityLogger")]
NuGet.Common.ILogger logger)
{
if (projectSystemCache == null)
{
throw new ArgumentNullException(nameof(projectSystemCache));
}
if (restoreWorker == null)
{
throw new ArgumentNullException(nameof(restoreWorker));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_projectSystemCache = projectSystemCache;
_restoreWorker = restoreWorker;
_logger = logger;
}
internal VSSolutionManager(
[Import(typeof(SVsServiceProvider))]
IServiceProvider serviceProvider,
IProjectSystemCache projectSystemCache,
NuGetProjectFactory projectSystemFactory,
ICredentialServiceProvider credentialServiceProvider,
IVsProjectAdapterProvider vsProjectAdapterProvider,
[Import("VisualStudioActivityLogger")]
Common.ILogger logger,
Lazy <ISettings> settings)
{
Assumes.Present(serviceProvider);
Assumes.Present(projectSystemCache);
Assumes.Present(projectSystemFactory);
Assumes.Present(credentialServiceProvider);
Assumes.Present(vsProjectAdapterProvider);
Assumes.Present(logger);
Assumes.Present(settings);
_serviceProvider = serviceProvider;
_projectSystemCache = projectSystemCache;
_projectSystemFactory = projectSystemFactory;
_credentialServiceProvider = credentialServiceProvider;
_vsProjectAdapterProvider = vsProjectAdapterProvider;
_logger = logger;
_settings = settings;
}
public LegacyCSProjPackageReferenceProjectProvider(IProjectSystemCache projectSystemCache)
{
if (projectSystemCache == null)
{
throw new ArgumentNullException(nameof(projectSystemCache));
}
_projectSystemCache = projectSystemCache;
}
public VsSolutionRestoreService(
IProjectSystemCache projectSystemCache,
ISolutionRestoreWorker restoreWorker,
[Import("VisualStudioActivityLogger")]
ILogger logger)
{
_projectSystemCache = projectSystemCache ?? throw new ArgumentNullException(nameof(projectSystemCache));
_restoreWorker = restoreWorker ?? throw new ArgumentNullException(nameof(restoreWorker));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
internal VsSolutionRestoreService(
IProjectSystemCache projectSystemCache,
ISolutionRestoreWorker restoreWorker,
ILogger logger,
Microsoft.VisualStudio.Threading.AsyncLazy <IVsSolution2> vsSolution2)
{
_projectSystemCache = projectSystemCache ?? throw new ArgumentNullException(nameof(projectSystemCache));
_restoreWorker = restoreWorker ?? throw new ArgumentNullException(nameof(restoreWorker));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_vsSolution2 = vsSolution2 ?? throw new ArgumentNullException(nameof(vsSolution2));
}
public CpsPackageReferenceProjectProvider(
IAsyncServiceProvider vsServiceProvider,
IProjectSystemCache projectSystemCache,
Lazy <IScriptExecutor> scriptExecutor)
{
Assumes.Present(vsServiceProvider);
Assumes.Present(projectSystemCache);
Assumes.Present(scriptExecutor);
_projectSystemCache = projectSystemCache;
_scriptExecutor = scriptExecutor;
}
public NetCorePackageReferenceProjectProvider(
[Import(typeof(SVsServiceProvider))]
IServiceProvider vsServiceProvider,
IProjectSystemCache projectSystemCache)
{
Assumes.Present(vsServiceProvider);
Assumes.Present(projectSystemCache);
_projectSystemCache = projectSystemCache;
_componentModel = new Lazy <IComponentModel>(
() => vsServiceProvider.GetService <SComponentModel, IComponentModel>());
}
public VsSolutionRestoreService(
IProjectSystemCache projectSystemCache,
ISolutionRestoreWorker restoreWorker,
[Import(nameof(VisualStudioActivityLogger))]
ILogger logger,
[Import(typeof(SAsyncServiceProvider))]
IAsyncServiceProvider serviceProvider
)
: this(
projectSystemCache,
restoreWorker,
logger,
new Microsoft.VisualStudio.Threading.AsyncLazy <IVsSolution2>(() => serviceProvider.GetServiceAsync <SVsSolution, IVsSolution2>(), NuGetUIThreadHelper.JoinableTaskFactory))
{
}
public NetCorePackageReferenceProjectProvider(
IAsyncServiceProvider vsServiceProvider,
IProjectSystemCache projectSystemCache)
{
Assumes.Present(vsServiceProvider);
Assumes.Present(projectSystemCache);
_projectSystemCache = projectSystemCache;
_componentModel = new AsyncLazy <IComponentModel>(
async() =>
{
return(await vsServiceProvider.GetServiceAsync <SComponentModel, IComponentModel>());
},
NuGetUIThreadHelper.JoinableTaskFactory);
}
internal VSSolutionManager(
IProjectSystemCache projectSystemCache,
NuGetProjectFactory projectSystemFactory,
ICredentialServiceProvider credentialServiceProvider,
IVsProjectAdapterProvider vsProjectAdapterProvider,
[Import("VisualStudioActivityLogger")]
Common.ILogger logger,
Lazy <ISettings> settings,
JoinableTaskContext joinableTaskContext)
: this(AsyncServiceProvider.GlobalProvider,
projectSystemCache,
projectSystemFactory,
credentialServiceProvider,
vsProjectAdapterProvider,
logger,
settings,
joinableTaskContext)
{
}
internal VSSolutionManager(
[Import(typeof(SVsServiceProvider))]
IServiceProvider serviceProvider,
IProjectSystemCache projectSystemCache,
NuGetProjectFactory projectSystemFactory,
ICredentialServiceProvider credentialServiceProvider,
[Import(typeof(VisualStudioActivityLogger))]
Common.ILogger logger)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (projectSystemCache == null)
{
throw new ArgumentNullException(nameof(projectSystemCache));
}
if (projectSystemFactory == null)
{
throw new ArgumentNullException(nameof(projectSystemFactory));
}
if (credentialServiceProvider == null)
{
throw new ArgumentNullException(nameof(credentialServiceProvider));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_serviceProvider = serviceProvider;
_projectSystemCache = projectSystemCache;
_projectSystemFactory = projectSystemFactory;
_credentialServiceProvider = credentialServiceProvider;
_logger = logger;
}
public NetCorePackageReferenceProjectProvider(IProjectSystemCache projectSystemCache)
{
Assumes.Present(projectSystemCache);
_projectSystemCache = projectSystemCache;
}
public NetCorePackageReferenceProjectProvider(IProjectSystemCache projectSystemCache)
: this(AsyncServiceProvider.GlobalProvider, projectSystemCache)
{
}
public CpsPackageReferenceProjectProvider(IProjectSystemCache projectSystemCache, Lazy <IScriptExecutor> scriptExecutor)
: this(AsyncServiceProvider.GlobalProvider, projectSystemCache, scriptExecutor)
{
}
