internal static LegacyPackageReferenceProject CreateLegacyPackageReferenceProject(TestDirectory testDirectory, string projectId, IVsProjectThreadingService threadingService, LibraryDependency[] pkgDependencies)
{
var framework = NuGetFramework.Parse("netstandard13");
IVsProjectAdapter projectAdapter = CreateProjectAdapter(testDirectory);
var projectServices = new TestProjectSystemServices();
projectServices.SetupInstalledPackages(
framework,
pkgDependencies);
var testProject = new LegacyPackageReferenceProject(
projectAdapter,
projectId,
projectServices,
threadingService);
return(testProject);
}
public DeferredProjectServicesProxy(
IVsProjectAdapter vsProjectAdapter,
IProjectSystemCapabilities deferredProjectCapabilities,
Func <INuGetProjectServices> getFallbackProjectServices,
IComponentModel componentModel)
{
Assumes.Present(vsProjectAdapter);
Assumes.Present(deferredProjectCapabilities);
Assumes.Present(getFallbackProjectServices);
Assumes.Present(componentModel);
_vsProjectAdapter = vsProjectAdapter;
_deferredProjectCapabilities = deferredProjectCapabilities;
_componentModel = componentModel;
_threadingService = _componentModel.GetService <IVsProjectThreadingService>();
_fallbackProjectServices = new Lazy <INuGetProjectServices>(getFallbackProjectServices);
_deferredProjectServices = new WorkspaceProjectServices(vsProjectAdapter, this);
}
/// <summary>
/// Creates an instance of <see cref="NuGetProject"/> of desired type.
/// </summary>
/// <typeparam name="TProject">Type of project to create.</typeparam>
/// <param name="vsProjectAdapter">Project adapter</param>
/// <param name="optionalContext">Optional context for project creation. Not all of providers require it.</param>
/// <returns>Instance of <see cref="NuGetProject"/> or null if failed.</returns>
/// <remarks>The factory will identify a provider corresponding to given project type and will attempt to force create the project of desired type.</remarks>
public async Task <TProject> CreateNuGetProjectAsync <TProject>(
IVsProjectAdapter vsProjectAdapter,
ProjectProviderContext optionalContext = null)
where TProject : NuGetProject
{
Assumes.Present(vsProjectAdapter);
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var provider = _providers
.FirstOrDefault(p => typeof(TProject).TypeHandle.Equals(p.ProjectType));
if (provider == null)
{
return(null);
}
if (vsProjectAdapter.VsHierarchy != null &&
VsHierarchyUtility.IsCPSCapabilityCompliant(vsProjectAdapter.VsHierarchy))
{
// Lazy load the CPS enabled JoinableTaskFactory for the UI.
NuGetUIThreadHelper.SetJoinableTaskFactoryFromService(ProjectServiceAccessor.Value as IProjectServiceAccessor);
}
try
{
var nuGetProject = await provider.TryCreateNuGetProjectAsync(
vsProjectAdapter,
optionalContext,
forceProjectType : true);
if (nuGetProject != null)
{
return(nuGetProject as TProject);
}
}
catch (Exception e)
{
_logger.LogError(e.ToString());
}
return(null);
}
public VsManagedLanguagesProjectSystemServices(
IVsProjectAdapter vsProjectAdapter,
IComponentModel componentModel,
bool nominatesOnSolutionLoad)
: base(componentModel)
{
Assumes.Present(vsProjectAdapter);
_vsProjectAdapter = vsProjectAdapter;
_threadingService = GetGlobalService <IVsProjectThreadingService>();
Assumes.Present(_threadingService);
_asVSProject4 = new Lazy <VSProject4>(() => vsProjectAdapter.Project.Object as VSProject4);
ScriptService = new VsProjectScriptHostService(vsProjectAdapter, this);
NominatesOnSolutionLoad = nominatesOnSolutionLoad;
}
public VsMSBuildNuGetProject(
IVsProjectAdapter projectAdapter,
IMSBuildProjectSystem msbuildNuGetProjectSystem,
string folderNuGetProjectPath,
string packagesConfigFolderPath,
INuGetProjectServices projectServices)
: base(
msbuildNuGetProjectSystem,
folderNuGetProjectPath,
packagesConfigFolderPath)
{
Assumes.Present(projectAdapter);
Assumes.Present(msbuildNuGetProjectSystem);
Assumes.Present(projectServices);
InternalMetadata.Add(NuGetProjectMetadataKeys.ProjectId, projectAdapter.ProjectId);
ProjectServices = projectServices;
}
public bool AddProject(ProjectNames projectNames, IVsProjectAdapter vsProjectAdapter, NuGetProject nuGetProject)
{
if (projectNames == null)
{
throw new ArgumentNullException(nameof(projectNames));
}
if (projectNames.FullName == null)
{
throw new ArgumentException(
message: string.Format(CultureInfo.CurrentCulture, Strings.PropertyCannotBeNull, nameof(projectNames.FullName)),
paramName: nameof(projectNames));
}
_readerWriterLock.EnterWriteLock();
try
{
UpdateProjectNamesCache(projectNames);
AddOrUpdateCacheEntry(
projectNames.FullName,
addEntryFactory: k => new CacheEntry
{
NuGetProject = nuGetProject,
VsProjectAdapter = vsProjectAdapter,
ProjectNames = projectNames
},
updateEntryFactory: (k, e) =>
{
e.NuGetProject = nuGetProject;
e.VsProjectAdapter = vsProjectAdapter;
e.ProjectNames = projectNames;
return(e);
});
}
finally
{
_readerWriterLock.ExitWriteLock();
}
return(true);
}
private async Task <INuGetProjectServices> CreateProjectServicesAsync(IVsProjectAdapter vsProjectAdapter)
{
var componentModel = await _componentModel.GetValueAsync();
if (vsProjectAdapter.IsDeferred)
{
return(new DeferredProjectServicesProxy(
vsProjectAdapter,
new DeferredProjectCapabilities {
SupportsPackageReferences = false
},
() => new VsCoreProjectSystemServices(vsProjectAdapter, componentModel),
componentModel));
}
else
{
return(new VsCoreProjectSystemServices(vsProjectAdapter, componentModel));
}
}
public bool AddProject(ProjectNames projectNames, IVsProjectAdapter vsProjectAdapter, NuGetProject nuGetProject)
{
if (projectNames == null)
{
throw new ArgumentNullException(nameof(projectNames));
}
if (projectNames.FullName == null)
{
throw new ArgumentNullException(nameof(projectNames.FullName));
}
_readerWriterLock.EnterWriteLock();
try
{
UpdateProjectNamesCache(projectNames);
AddOrUpdateCacheEntry(
projectNames.FullName,
addEntryFactory: k => new CacheEntry
{
NuGetProject = nuGetProject,
VsProjectAdapter = vsProjectAdapter,
ProjectNames = projectNames
},
updateEntryFactory: (k, e) =>
{
e.NuGetProject = nuGetProject;
e.VsProjectAdapter = vsProjectAdapter;
e.ProjectNames = projectNames;
UpdateProjectIdInPackageSpec(nuGetProject, projectNames.UniqueName, e.ProjectRestoreInfo);
return(e);
});
}
finally
{
_readerWriterLock.ExitWriteLock();
}
return(true);
}
public static async Task <IEnumerable <AssemblyBinding> > AddBindingRedirectsAsync(
ISolutionManager solutionManager,
IVsProjectAdapter vsProjectAdapter,
AppDomain domain,
IDictionary <string, HashSet <string> > projectAssembliesCache,
IVsFrameworkMultiTargeting frameworkMultiTargeting,
INuGetProjectContext nuGetProjectContext)
{
// Run this on the UI thread since it enumerates all references
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var redirects = Enumerable.Empty <AssemblyBinding>();
var msBuildNuGetProjectSystem = GetMSBuildNuGetProjectSystem(solutionManager, vsProjectAdapter);
// If no msBuildNuGetProjectSystem, no binding redirects. Bail
if (msBuildNuGetProjectSystem == null)
{
return(redirects);
}
// Get the full path from envDTEProject
var root = vsProjectAdapter.FullPath;
IEnumerable <string> assemblies = EnvDTEProjectUtility.GetAssemblyClosure(vsProjectAdapter.Project, projectAssembliesCache);
redirects = BindingRedirectResolver.GetBindingRedirects(assemblies, domain);
if (frameworkMultiTargeting != null)
{
// filter out assemblies that already exist in the target framework (CodePlex issue #3072)
var targetFrameworkName = EnvDTEProjectInfoUtility.GetDotNetFrameworkName(vsProjectAdapter.Project);
redirects = redirects.Where(p => !FrameworkAssemblyResolver.IsHigherAssemblyVersionInFramework(p.Name, p.AssemblyNewVersion, targetFrameworkName));
}
// Create a binding redirect manager over the configuration
var manager = new BindingRedirectManager(EnvDTEProjectInfoUtility.GetConfigurationFile(vsProjectAdapter.Project), msBuildNuGetProjectSystem);
// Add the redirects
manager.AddBindingRedirects(redirects);
return(redirects);
}
public async Task GetInstalledVersion_WithoutAssetsFile_ReturnsVersionsFromPackageSpecs()
{
using (var testDirectory = TestDirectory.Create())
{
// Setup
var projectName = "project1";
var projectFullPath = Path.Combine(testDirectory.Path, projectName + ".csproj");
// Project
var projectCache = new ProjectSystemCache();
IVsProjectAdapter projectAdapter = (new Mock <IVsProjectAdapter>()).Object;
var project = CreateNetCorePackageReferenceProject(projectName, projectFullPath, projectCache);
var projectNames = GetTestProjectNames(projectFullPath, projectName);
var packageSpec = GetPackageSpec(projectName, projectFullPath, "[2.0.0, )");
// Restore info
var projectRestoreInfo = ProjectJsonTestHelpers.GetDGSpecFromPackageSpecs(packageSpec);
projectCache.AddProjectRestoreInfo(projectNames, projectRestoreInfo, new List <IAssetsLogMessage>());
projectCache.AddProject(projectNames, projectAdapter, project).Should().BeTrue();
// Package directories
var sources = new List <PackageSource>();
var packagesDir = new DirectoryInfo(Path.Combine(testDirectory, "globalPackages"));
var packageSource = new DirectoryInfo(Path.Combine(testDirectory, "packageSource"));
packagesDir.Create();
packageSource.Create();
sources.Add(new PackageSource(packageSource.FullName));
var logger = new TestLogger();
// Act
var packages = await project.GetInstalledPackagesAsync(CancellationToken.None);
// Asert
packages.Should().Contain(a => a.PackageIdentity.Equals(new PackageIdentity("packageA", new NuGetVersion("2.0.0"))));
var cache_packages = await project.GetInstalledPackagesAsync(CancellationToken.None);
cache_packages.Should().Contain(a => a.PackageIdentity.Equals(new PackageIdentity("packageA", new NuGetVersion("2.0.0"))));
}
}
public static VsMSBuildProjectSystem CreateMSBuildNuGetProjectSystem(IVsProjectAdapter vsProjectAdapter, INuGetProjectContext nuGetProjectContext)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (vsProjectAdapter == null)
{
throw new ArgumentNullException(nameof(vsProjectAdapter));
}
if (string.IsNullOrEmpty(vsProjectAdapter.FullName))
{
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
Strings.DTE_ProjectUnsupported, vsProjectAdapter.ProjectName));
}
if (!vsProjectAdapter.IsDeferred &&
EnvDTEProjectUtility.SupportsProjectKPackageManager(vsProjectAdapter.Project))
{
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture, Strings.DTE_ProjectUnsupported, typeof(IMSBuildProjectSystem).FullName));
}
var guids = vsProjectAdapter.ProjectTypeGuids;
if (guids.Contains(VsProjectTypes.CppProjectTypeGuid)) // Got a cpp project
{
return(new NativeProjectSystem(vsProjectAdapter, nuGetProjectContext));
}
// Try to get a factory for the project type guid
foreach (var guid in guids)
{
if (_factories.TryGetValue(guid, out var factory))
{
return(factory(vsProjectAdapter, nuGetProjectContext));
}
}
// Fall back to the default if we have no special project types
return(new VsMSBuildProjectSystem(vsProjectAdapter, nuGetProjectContext));
}
private static async Task AddBindingRedirectsAsync(VSSolutionManager vsSolutionManager,
IVsProjectAdapter vsProjectAdapter,
AppDomain domain,
HashSet <string> visitedProjects,
Dictionary <string, HashSet <string> > projectAssembliesCache,
IVsFrameworkMultiTargeting frameworkMultiTargeting,
IDictionary <string, List <IVsProjectAdapter> > dependentEnvDTEProjectsDictionary,
INuGetProjectContext nuGetProjectContext)
{
Assumes.Present(vsProjectAdapter);
// Need to be on the UI thread
ThreadHelper.ThrowIfNotOnUIThread();
var envDTEProjectUniqueName = vsProjectAdapter.UniqueName;
if (visitedProjects.Contains(envDTEProjectUniqueName))
{
return;
}
if (await SupportsBindingRedirectsAsync(vsProjectAdapter.Project))
{
await AddBindingRedirectsAsync(vsSolutionManager, vsProjectAdapter, domain, projectAssembliesCache, frameworkMultiTargeting, nuGetProjectContext);
}
// Add binding redirects to all envdteprojects that are referencing this one
foreach (var dependentEnvDTEProject in GetDependentProjects(dependentEnvDTEProjectsDictionary, vsProjectAdapter))
{
await AddBindingRedirectsAsync(
vsSolutionManager,
dependentEnvDTEProject,
domain,
visitedProjects,
projectAssembliesCache,
frameworkMultiTargeting,
dependentEnvDTEProjectsDictionary,
nuGetProjectContext);
}
visitedProjects.Add(envDTEProjectUniqueName);
}
public WorkspaceProjectServices(
IVsProjectAdapter vsProjectAdapter,
INuGetProjectServices projectServices)
{
Assumes.Present(vsProjectAdapter);
Assumes.Present(projectServices);
_vsProjectAdapter = vsProjectAdapter;
_fullProjectPath = vsProjectAdapter.FullProjectPath;
_workspaceService = projectServices.GetGlobalService <IDeferredProjectWorkspaceService>();
Assumes.Present(_workspaceService);
_threadingService = projectServices.GetGlobalService <IVsProjectThreadingService>();
Assumes.Present(_threadingService);
_buildProjectDataService = new AsyncLazy <IMSBuildProjectDataService>(
() => _workspaceService.GetMSBuildProjectDataServiceAsync(_fullProjectPath),
_threadingService.JoinableTaskFactory);
}
private INuGetProjectServices CreateProjectServices(
IVsProjectAdapter vsProjectAdapter, VsMSBuildProjectSystem projectSystem)
{
var componentModel = _componentModel.Value;
if (vsProjectAdapter.IsDeferred)
{
return(new DeferredProjectServicesProxy(
vsProjectAdapter,
new DeferredProjectCapabilities {
SupportsPackageReferences = false
},
() => new VsMSBuildProjectSystemServices(vsProjectAdapter, projectSystem, componentModel),
componentModel));
}
else
{
return(new VsMSBuildProjectSystemServices(vsProjectAdapter, projectSystem, componentModel));
}
}
public VsMSBuildProjectSystemServices(
IVsProjectAdapter vsProjectAdapter,
VsMSBuildProjectSystem vsProjectSystem,
IVsProjectThreadingService threadingService,
Lazy <IScriptExecutor> scriptExecutor)
{
Assumes.Present(vsProjectAdapter);
Assumes.Present(vsProjectSystem);
Assumes.Present(threadingService);
Assumes.Present(scriptExecutor);
_vsProjectAdapter = vsProjectAdapter;
_vsProjectSystem = vsProjectSystem;
_threadingService = threadingService;
ReferencesReader = vsProjectSystem is CpsProjectSystem ?
new CpsProjectSystemReferenceReader(vsProjectAdapter, _threadingService) :
new VsCoreProjectSystemReferenceReader(vsProjectAdapter, _threadingService);
ScriptService = new VsProjectScriptHostService(vsProjectAdapter, scriptExecutor);
}
private async Task <IVsPathContext> GetPathContextForPackagesConfigAsync(
IVsProjectAdapter vsProjectAdapter, CancellationToken token)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var props = new Dictionary <string, object>();
props.Add(NuGetProjectMetadataKeys.Name, Path.GetFileNameWithoutExtension(vsProjectAdapter.FullProjectPath));
props.Add(NuGetProjectMetadataKeys.TargetFramework, await vsProjectAdapter.GetTargetFrameworkAsync());
var packagesProject = new PackagesConfigNuGetProject(vsProjectAdapter.ProjectDirectory, props);
var packagesFolderPath = PackagesFolderPathUtility.GetPackagesFolderPath(_solutionManager.Value, _settings.Value);
var folderProject = new FolderNuGetProject(packagesFolderPath);
// switch to a background thread to process packages data
await TaskScheduler.Default;
var packageReferences = await packagesProject.GetInstalledPackagesAsync(token);
var trie = new PathLookupTrie <string>();
foreach (var pid in packageReferences.Select(pr => pr.PackageIdentity))
{
var packageInstallPath = folderProject.GetInstalledPath(pid);
if (string.IsNullOrEmpty(packageInstallPath))
{
throw new KeyNotFoundException(string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_PackageDirectoryNotFound, pid));
}
trie[packageInstallPath] = packageInstallPath;
}
var pathContext = GetSolutionPathContext();
return(new VsIndexedPathContext(
pathContext.UserPackageFolder,
pathContext.FallbackPackageFolders.Cast <string>(),
trie));
}
public CpsProjectSystemReferenceReader(
IVsProjectAdapter vsProjectAdapter,
IVsProjectThreadingService threadingService)
{
Assumes.Present(vsProjectAdapter);
Assumes.Present(threadingService);
_vsProjectAdapter = vsProjectAdapter;
_threadingService = threadingService;
_unconfiguredProject = new AsyncLazy <UnconfiguredProject>(async() =>
{
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var context = _vsProjectAdapter.Project as IVsBrowseObjectContext;
if (context == null)
{
// VC implements this on their DTE.Project.Object
context = _vsProjectAdapter.Project.Object as IVsBrowseObjectContext;
}
return(context?.UnconfiguredProject);
}, threadingService.JoinableTaskFactory);
}
public VsManagedLanguagesProjectSystemServices(
IVsProjectAdapter vsProjectAdapter,
IVsProjectThreadingService threadingService,
bool nominatesOnSolutionLoad,
Lazy <IScriptExecutor> scriptExecutor)
{
Assumes.Present(vsProjectAdapter);
Assumes.Present(threadingService);
_vsProjectAdapter = vsProjectAdapter;
_threadingService = threadingService;
_asVSProject4 = new Lazy <VSProject4>(() =>
{
ThreadHelper.ThrowIfNotOnUIThread();
return(vsProjectAdapter.Project.Object as VSProject4);
});
ScriptService = new VsProjectScriptHostService(vsProjectAdapter, scriptExecutor);
NominatesOnSolutionLoad = nominatesOnSolutionLoad;
}
/// <summary>
/// Tries to create an instance of <see cref="NuGetProject"/> by calling registered
/// providers in predefined order.
/// </summary>
/// <param name="vsProjectAdapter">A project adapter.</param>
/// <param name="context">Project context</param>
/// <param name="result">New project instance when <code>true</code> is returned.
/// Otherwise - <code>null</code>.</param>
/// <returns><code>true</code> when new project instance has been successfully created.</returns>
public async Task <NuGetProject> TryCreateNuGetProjectAsync(
IVsProjectAdapter vsProjectAdapter,
ProjectProviderContext context)
{
Assumes.Present(vsProjectAdapter);
Assumes.Present(context);
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var exceptions = new List <Exception>();
foreach (var provider in _providers)
{
try
{
var nuGetProject = await provider.TryCreateNuGetProjectAsync(
vsProjectAdapter,
context,
forceProjectType : false);
if (nuGetProject != null)
{
return(nuGetProject);
}
}
catch (Exception e)
{
// Ignore failures. If this method returns null, the problem falls
// into one of the other NuGet project types.
exceptions.Add(e);
}
}
exceptions.ForEach(e => _logger.LogError(e.ToString()));
return(null);
}
/// <summary>
/// Creates an instance of <see cref="NuGetProject"/> of desired type.
/// </summary>
/// <typeparam name="TProject">Type of project to create.</typeparam>
/// <param name="vsProjectAdapter">Project adapter</param>
/// <param name="optionalContext">Optional context for project creation. Not all of providers require it.</param>
/// <returns>Instance of <see cref="NuGetProject"/> or null if failed.</returns>
/// <remarks>The factory will identify a provider corresponding to given project type and will attempt to force create the project of desired type.</remarks>
public async Task <TProject> CreateNuGetProjectAsync <TProject>(
IVsProjectAdapter vsProjectAdapter,
ProjectProviderContext optionalContext = null)
where TProject : NuGetProject
{
Assumes.Present(vsProjectAdapter);
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var provider = _providers
.FirstOrDefault(p => typeof(TProject).TypeHandle.Equals(p.ProjectType));
if (provider == null)
{
return(null);
}
try
{
var nuGetProject = await provider.TryCreateNuGetProjectAsync(
vsProjectAdapter,
optionalContext,
forceProjectType : true);
if (nuGetProject != null)
{
return(nuGetProject as TProject);
}
}
catch (Exception e)
{
_logger.LogError(e.ToString());
}
return(null);
}
public async Task <IVsPathContext> CreatePathContextAsync(
IVsProjectAdapter vsProjectAdapter,
string projectAssetsFile,
string projectUniqueName,
CancellationToken token)
{
IVsPathContext context = null;
try
{
// First check for project.assets.json file and generate VsPathContext from there.
if (!string.IsNullOrEmpty(projectAssetsFile))
{
context = GetPathContextFromProjectLockFile(projectAssetsFile);
}
// if no project.assets.json file, then check for project.lock.json file.
context = context ?? GetPathContextForProjectJson(vsProjectAdapter);
// if no project.lock.json file, then look for packages.config file.
context = context ?? await GetPathContextForPackagesConfigAsync(vsProjectAdapter, token);
// Fallback to reading the path context from the solution's settings. Note that project level settings in
// VS are not currently supported.
context = context ?? GetSolutionPathContext();
}
catch (Exception e) when(e is KeyNotFoundException || e is InvalidOperationException)
{
var errorMessage = string.Format(CultureInfo.CurrentCulture, VsResources.PathContext_CreateContextError, projectUniqueName, e.Message);
_logger.Value.LogError(errorMessage);
throw new InvalidOperationException(errorMessage, e);
}
return(context);
}
public async Task <NuGetProject> TryCreateNuGetProjectAsync(
IVsProjectAdapter vsProjectAdapter,
ProjectProviderContext _,
bool forceProjectType)
{
Assumes.Present(vsProjectAdapter);
await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync();
var projectServices = await TryCreateProjectServicesAsync(
vsProjectAdapter,
forceCreate : forceProjectType);
if (projectServices == null)
{
return(null);
}
return(new LegacyPackageReferenceProject(
vsProjectAdapter,
vsProjectAdapter.ProjectId,
projectServices,
_threadingService));
}
private void AddVsProjectAdapterToCache(IVsProjectAdapter vsProjectAdapter)
{
ThreadHelper.ThrowIfNotOnUIThread();
if (!vsProjectAdapter.IsSupported)
{
return;
}
_projectSystemCache.TryGetProjectNameByShortName(vsProjectAdapter.ProjectName, out ProjectNames oldProjectName);
// Create the NuGet project first. If this throws we bail out and do not change the cache.
var nuGetProject = CreateNuGetProject(vsProjectAdapter);
// Then create the project name from the project.
var newProjectName = vsProjectAdapter.ProjectNames;
// Finally, try to add the project to the cache.
var added = _projectSystemCache.AddProject(newProjectName, vsProjectAdapter, nuGetProject);
if (added && nuGetProject != null)
{
// Emit project specific telemetry as we are adding the project to the cache.
// This ensures we do not emit the events over and over while the solution is
// open.
NuGetProjectTelemetryService.Instance.EmitNuGetProject(nuGetProject);
}
if (string.IsNullOrEmpty(DefaultNuGetProjectName) ||
newProjectName.ShortName.Equals(DefaultNuGetProjectName, StringComparison.OrdinalIgnoreCase))
{
DefaultNuGetProjectName = oldProjectName != null ?
oldProjectName.CustomUniqueName :
newProjectName.ShortName;
}
}
private async Task <bool> IsWebSiteAsync(IVsProjectAdapter project)
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
return((await project.GetProjectTypeGuidsAsync()).Contains(VsProjectTypes.WebSiteProjectTypeGuid));
}
private async Task ReloadProjectAsync(IVsProjectAdapter project)
{
project = await _solutionManager.Value.GetVsProjectAdapterAsync(project.FullName);
}
public async static Task <VsMSBuildProjectSystem> CreateMSBuildNuGetProjectSystemAsync(IVsProjectAdapter vsProjectAdapter, INuGetProjectContext nuGetProjectContext)
{
if (vsProjectAdapter == null)
{
throw new ArgumentNullException(nameof(vsProjectAdapter));
}
if (string.IsNullOrEmpty(vsProjectAdapter.FullName))
{
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
Strings.DTE_ProjectUnsupported, vsProjectAdapter.ProjectName));
}
var guids = await vsProjectAdapter.GetProjectTypeGuidsAsync();
if (guids.Contains(VsProjectTypes.CppProjectTypeGuid)) // Got a cpp project
{
return(new NativeProjectSystem(vsProjectAdapter, nuGetProjectContext));
}
// Try to get a factory for the project type guid
foreach (var guid in guids)
{
if (_factories.TryGetValue(guid, out var factory))
{
return(factory(vsProjectAdapter, nuGetProjectContext));
}
}
// Fall back to the default if we have no special project types
return(new VsMSBuildProjectSystem(vsProjectAdapter, nuGetProjectContext));
}
public JsProjectSystem(IVsProjectAdapter vsProjectAdapter, INuGetProjectContext nuGetProjectContext)
: base(vsProjectAdapter, nuGetProjectContext)
{
}
private async static Task <IMSBuildProjectSystem> GetMSBuildNuGetProjectSystemAsync(ISolutionManager solutionManager, IVsProjectAdapter vsProjectAdapter)
{
var nuGetProject = await solutionManager.GetNuGetProjectAsync(vsProjectAdapter.ProjectName);
if (nuGetProject != null)
{
var msBuildNuGetProject = nuGetProject as MSBuildNuGetProject;
if (msBuildNuGetProject != null)
{
return(msBuildNuGetProject.ProjectSystem);
}
}
return(null);
}
private INuGetProjectServices CreateCoreProjectSystemServices(
IVsProjectAdapter vsProjectAdapter, IComponentModel componentModel)
{
return(new VsManagedLanguagesProjectSystemServices(vsProjectAdapter, componentModel));
}
private async Task <INuGetProjectServices> CreateProjectServicesAsync(IVsProjectAdapter vsProjectAdapter)
{
var componentModel = await _componentModel.GetValueAsync();
return(new VsCoreProjectSystemServices(vsProjectAdapter, componentModel));
}
