public async Task <NuGetProject> UpdateNuGetProjectToPackageRef(NuGetProject oldProject) { #if VS14 // do nothing for VS 2015 and simply return the existing NuGetProject if (NuGetProjectUpdated != null) { NuGetProjectUpdated(this, new NuGetProjectEventArgs(oldProject)); } return(await Task.FromResult(oldProject)); #else if (oldProject == null) { throw new ArgumentException( ProjectManagement.Strings.Argument_Cannot_Be_Null_Or_Empty, nameof(oldProject)); } var projectName = GetNuGetProjectSafeName(oldProject); var dteProject = GetDTEProject(projectName); ProjectNames oldEnvDTEProjectName; _projectSystemCache.TryGetProjectNames(projectName, out oldEnvDTEProjectName); RemoveEnvDTEProjectFromCache(projectName); var nuGetProject = await NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() => { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var settings = ServiceLocator.GetInstance <ISettings>(); var context = new ProjectSystemProviderContext( EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, settings)); return(new LegacyCSProjPackageReferenceProject( new EnvDTEProjectAdapter(dteProject), VsHierarchyUtility.GetProjectId(dteProject))); }); var added = _projectSystemCache.AddProject(oldEnvDTEProjectName, dteProject, nuGetProject); if (NuGetProjectUpdated != null) { NuGetProjectUpdated(this, new NuGetProjectEventArgs(nuGetProject)); } return(nuGetProject); #endif }
public static string GetSKU() { DTE dte = ServiceLocator.GetInstance <DTE>(); string sku = dte.Edition; if (sku.Equals("Ultimate", StringComparison.OrdinalIgnoreCase) || sku.Equals("Premium", StringComparison.OrdinalIgnoreCase) || sku.Equals("Professional", StringComparison.OrdinalIgnoreCase)) { sku = "Pro"; } return(sku); }
/// <summary> /// Sets NuGetPackageImportStamp to a new random guid. This is a hack to let the project system know it is out of date. /// The value does not matter, it just needs to change. /// </summary> protected static void UpdateImportStamp(EnvDTEProject envDTEProject, bool isCpsProjectSystem = false) { // There is no reason to call this for pre-Dev12 project systems. if (VSVersionHelper.VsMajorVersion >= 12) { #if VS14 // Switch to UI thread to update Import Stamp for Dev14. if (isCpsProjectSystem && VSVersionHelper.IsVisualStudio2014) { try { var projectServiceAccessor = ServiceLocator.GetInstance <IProjectServiceAccessor>(); ProjectService projectService = projectServiceAccessor.GetProjectService(); IThreadHandling threadHandling = projectService.Services.ThreadingPolicy; threadHandling.SwitchToUIThread(); } catch (Exception ex) { ExceptionHelper.WriteToActivityLog(ex); } } #endif IVsBuildPropertyStorage propStore = VsHierarchyUtility.ToVsHierarchy(envDTEProject) as IVsBuildPropertyStorage; if (propStore != null) { // <NuGetPackageImportStamp>af617720</NuGetPackageImportStamp> string stamp = Guid.NewGuid().ToString().Split('-')[0]; try { int r1 = propStore.SetPropertyValue(NuGetImportStamp, string.Empty, (uint)_PersistStorageType.PST_PROJECT_FILE, stamp); } catch (Exception ex1) { ExceptionHelper.WriteToActivityLog(ex1); } // Remove the NuGetImportStamp so that VC++ project file won't be updated with this stamp on disk, // which causes unnecessary source control pending changes. try { int r2 = propStore.RemoveProperty(NuGetImportStamp, string.Empty, (uint)_PersistStorageType.PST_PROJECT_FILE); } catch (Exception ex2) { ExceptionHelper.WriteToActivityLog(ex2); } } } }
public static IVsHierarchy ToVsHierarchy(Project project) { IVsHierarchy hierarchy; // Get the vs solution IVsSolution solution = ServiceLocator.GetInstance <IVsSolution>(); int hr = solution.GetProjectOfUniqueName(EnvDTEProjectUtility.GetUniqueName(project), out hierarchy); if (hr != NuGetVSConstants.S_OK) { Marshal.ThrowExceptionForHR(hr); } return(hierarchy); }
public VSSolutionManager() { _dte = ServiceLocator.GetInstance <DTE>(); _vsSolution = ServiceLocator.GetGlobalService <SVsSolution, IVsSolution>(); _vsMonitorSelection = ServiceLocator.GetGlobalService <SVsShellMonitorSelection, IVsMonitorSelection>(); // Keep a reference to SolutionEvents so that it doesn't get GC'ed. Otherwise, we won't receive events. _solutionEvents = _dte.Events.SolutionEvents; // can be null in unit tests if (_vsMonitorSelection != null) { Guid solutionLoadedGuid = VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_guid; _vsMonitorSelection.GetCmdUIContextCookie(ref solutionLoadedGuid, out _solutionLoadedUICookie); uint cookie; int hr = _vsMonitorSelection.AdviseSelectionEvents(this, out cookie); ErrorHandler.ThrowOnFailure(hr); } // Allow this constructor to be invoked from either the UI or a worker thread. This JTF call should be // cheap (minimal context switch cost) when we are already on the UI thread. ThreadHelper.JoinableTaskFactory.Run(async delegate { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); UserAgent.SetUserAgentString( new UserAgentStringBuilder().WithVisualStudioSKU(VSVersionHelper.GetFullVsVersionString())); }); _solutionEvents.BeforeClosing += OnBeforeClosing; _solutionEvents.AfterClosing += OnAfterClosing; _solutionEvents.ProjectAdded += OnEnvDTEProjectAdded; _solutionEvents.ProjectRemoved += OnEnvDTEProjectRemoved; _solutionEvents.ProjectRenamed += OnEnvDTEProjectRenamed; var vSStd97CmdIDGUID = VSConstants.GUID_VSStandardCommandSet97.ToString("B"); var solutionSaveID = (int)VSConstants.VSStd97CmdID.SaveSolution; var solutionSaveAsID = (int)VSConstants.VSStd97CmdID.SaveSolutionAs; _solutionSaveEvent = _dte.Events.CommandEvents[vSStd97CmdIDGUID, solutionSaveID]; _solutionSaveAsEvent = _dte.Events.CommandEvents[vSStd97CmdIDGUID, solutionSaveAsID]; _solutionSaveEvent.BeforeExecute += SolutionSaveAs_BeforeExecute; _solutionSaveEvent.AfterExecute += SolutionSaveAs_AfterExecute; _solutionSaveAsEvent.BeforeExecute += SolutionSaveAs_BeforeExecute; _solutionSaveAsEvent.AfterExecute += SolutionSaveAs_AfterExecute; }
public static bool?ShowQueryMessage(string message, string title, bool showCancelButton) { int result = VsShellUtilities.ShowMessageBox( ServiceLocator.GetInstance <IServiceProvider>(), message, title, OLEMSGICON.OLEMSGICON_QUERY, showCancelButton ? OLEMSGBUTTON.OLEMSGBUTTON_YESNOCANCEL : OLEMSGBUTTON.OLEMSGBUTTON_YESNO, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST); if (result == NativeMethods.IDCANCEL) { return(null); } return(result == NativeMethods.IDYES); }
private NuGetProject CreateNuGetProject(Project envDTEProject, INuGetProjectContext projectContext = null) { var settings = ServiceLocator.GetInstance <ISettings>(); var context = new ProjectSystemProviderContext( projectContext ?? EmptyNuGetProjectContext, () => PackagesFolderPathUtility.GetPackagesFolderPath(this, settings)); NuGetProject result; if (_projectSystemFactory.TryCreateNuGetProject(envDTEProject, context, out result)) { return(result); } return(null); }
public static string GetFullVsVersionString() { ThreadHelper.ThrowIfNotOnUIThread(); DTE dte = ServiceLocator.GetInstance <DTE>(); // On Dev14, dte.Edition just returns SKU, such as "Enterprise" // Add "VS" to the string so that in user agent header, it will be "VS Enterprise/14.0". string edition = dte.Edition; if (!edition.StartsWith("VS", StringComparison.OrdinalIgnoreCase)) { edition = "VS " + edition; } return(edition + "/" + dte.Version); }
public static async Task CollapseAllNodesAsync(ISolutionManager solutionManager, IDictionary <string, ISet <VsHierarchyItem> > ignoreNodes) { // this operation needs to execute on UI thread await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var dte = ServiceLocator.GetInstance <DTE>(); var projects = dte.Solution.Projects; foreach (Project project in projects) { ISet <VsHierarchyItem> expandedNodes; if (ignoreNodes.TryGetValue(EnvDTEProjectUtility.GetUniqueName(project), out expandedNodes) && expandedNodes != null) { CollapseProjectHierarchyItems(project, expandedNodes); } } }
public static async TaskExpandedNodes GetAllExpandedNodesAsync(ISolutionManager solutionManager) { // this operation needs to execute on UI thread await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var dte = ServiceLocator.GetInstance <DTE>(); var projects = dte.Solution.Projects; var results = new Dictionary <string, ISet <VsHierarchyItem> >(StringComparer.OrdinalIgnoreCase); foreach (Project project in projects) { ICollection <VsHierarchyItem> expandedNodes = GetExpandedProjectHierarchyItems(project); Debug.Assert(!results.ContainsKey(EnvDTEProjectUtility.GetUniqueName(project))); results[EnvDTEProjectUtility.GetUniqueName(project)] = new HashSet <VsHierarchyItem>(expandedNodes); } return(results); }
public VSSolutionManager() { _dte = ServiceLocator.GetInstance <DTE>(); _vsSolution = ServiceLocator.GetGlobalService <SVsSolution, IVsSolution>(); _vsMonitorSelection = ServiceLocator.GetGlobalService <SVsShellMonitorSelection, IVsMonitorSelection>(); // Keep a reference to SolutionEvents so that it doesn't get GC'ed. Otherwise, we won't receive events. _solutionEvents = _dte.Events.SolutionEvents; // can be null in unit tests if (_vsMonitorSelection != null) { Guid solutionLoadedGuid = VSConstants.UICONTEXT.SolutionExistsAndFullyLoaded_guid; _vsMonitorSelection.GetCmdUIContextCookie(ref solutionLoadedGuid, out _solutionLoadedUICookie); uint cookie; int hr = _vsMonitorSelection.AdviseSelectionEvents(this, out cookie); ErrorHandler.ThrowOnFailure(hr); } UserAgent.SetUserAgentString( new UserAgentStringBuilder().WithVisualStudioSKU(VSVersionHelper.GetFullVsVersionString())); _solutionEvents.BeforeClosing += OnBeforeClosing; _solutionEvents.AfterClosing += OnAfterClosing; _solutionEvents.ProjectAdded += OnEnvDTEProjectAdded; _solutionEvents.ProjectRemoved += OnEnvDTEProjectRemoved; _solutionEvents.ProjectRenamed += OnEnvDTEProjectRenamed; var vSStd97CmdIDGUID = VSConstants.GUID_VSStandardCommandSet97.ToString("B"); var solutionSaveID = (int)VSConstants.VSStd97CmdID.SaveSolution; var solutionSaveAsID = (int)VSConstants.VSStd97CmdID.SaveSolutionAs; _solutionSaveEvent = _dte.Events.CommandEvents[vSStd97CmdIDGUID, solutionSaveID]; _solutionSaveAsEvent = _dte.Events.CommandEvents[vSStd97CmdIDGUID, solutionSaveAsID]; _solutionSaveEvent.BeforeExecute += SolutionSaveAs_BeforeExecute; _solutionSaveEvent.AfterExecute += SolutionSaveAs_AfterExecute; _solutionSaveAsEvent.BeforeExecute += SolutionSaveAs_BeforeExecute; _solutionSaveAsEvent.AfterExecute += SolutionSaveAs_AfterExecute; }
public static IVsProjectBuildSystem GetVsProjectBuildSystem(EnvDTE.Project project) { if (project == null) { throw new ArgumentNullException(nameof(project)); } return(NuGetUIThreadHelper.JoinableTaskFactory.Run(async() => { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); // Get the vs solution IVsSolution solution = ServiceLocator.GetInstance <IVsSolution>(); IVsHierarchy hierarchy; var hr = solution.GetProjectOfUniqueName(EnvDTEProjectInfoUtility.GetUniqueName(project), out hierarchy); if (hr != VSConstants.S_OK) { Marshal.ThrowExceptionForHR(hr); } return hierarchy as IVsProjectBuildSystem; })); }
public async Task <IEnumerable <ProjectRestoreReference> > GetProjectReferencesAsync( Common.ILogger logger, CancellationToken _) { // DTE calls need to be done from the main thread await _threadingService.JoinableTaskFactory.SwitchToMainThreadAsync(); var results = new List <ProjectRestoreReference>(); var itemsFactory = ServiceLocator.GetInstance <IVsEnumHierarchyItemsFactory>(); // Verify ReferenceOutputAssembly var excludedProjects = GetExcludedReferences(itemsFactory, logger); var hasMissingReferences = false; // find all references in the project foreach (var childReference in GetVSProjectReferences()) { try { var reference3 = childReference as Reference3; // Verify that this is a project reference if (IsProjectReference(reference3, logger)) { // Verify that this is a valid and resolved project reference if (!IsReferenceResolved(reference3, logger)) { hasMissingReferences = true; continue; } if (EnvDTEProjectUtility.HasUnsupportedProjectCapability(reference3.SourceProject)) { // Skip this shared project continue; } var childProjectPath = EnvDTEProjectInfoUtility.GetFullProjectPath(reference3.SourceProject); // Skip projects which have ReferenceOutputAssembly=false if (!string.IsNullOrEmpty(childProjectPath) && !excludedProjects.Contains(childProjectPath, StringComparer.OrdinalIgnoreCase)) { var restoreReference = new ProjectRestoreReference() { ProjectPath = childProjectPath, ProjectUniqueName = childProjectPath }; results.Add(restoreReference); } } else { hasMissingReferences = true; } } catch (Exception ex) { // Exceptions are expected in some scenarios for native projects, // ignore them and show a warning hasMissingReferences = true; logger.LogDebug(ex.ToString()); Debug.Fail("Unable to find project dependencies: " + ex.ToString()); } } if (hasMissingReferences) { // Log a generic message once per project if any items could not be resolved. // In most cases this can be ignored, but in the rare case where the unresolved // item is actually a project the restore result will be incomplete. var message = string.Format( CultureInfo.CurrentCulture, Strings.UnresolvedItemDuringProjectClosureWalk, _vsProjectAdapter.UniqueName); logger.LogVerbose(message); } return(results); }
public VsMachineWideSettings() : this(ServiceLocator.GetInstance <DTE>()) { }
/// <summary> /// Creates a new instance of <see cref="VsDeleteOnRestartManager"/>. /// </summary> public VsDeleteOnRestartManager() : this( ServiceLocator.GetInstance<Configuration.ISettings>(), ServiceLocator.GetInstance<ISolutionManager>()) { }
/// <summary> /// Returns the closure of all project to project references below this project. /// </summary> /// <remarks>This uses DTE and should be called from the UI thread.</remarks> public override async Task <IReadOnlyList <ExternalProjectReference> > GetProjectReferenceClosureAsync( ExternalProjectReferenceContext context) { var logger = context.Logger; var cache = context.Cache; // DTE calls need to be done from the main thread await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var results = new HashSet <ExternalProjectReference>(); // projects to walk - DFS var toProcess = new Stack <DTEReference>(); // keep track of found projects to avoid duplicates var rootProjectPath = EnvDTEProjectUtility.GetFullProjectPath(EnvDTEProject); // start with the current project toProcess.Push(new DTEReference(EnvDTEProject, rootProjectPath)); var itemsFactory = ServiceLocator.GetInstance <IVsEnumHierarchyItemsFactory>(); var uniqueNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase); // continue walking all project references until we run out while (toProcess.Count > 0) { var dteReference = toProcess.Pop(); // Find the path of the current project var projectFileFullPath = dteReference.Path; var project = dteReference.Project; if (string.IsNullOrEmpty(projectFileFullPath) || !uniqueNames.Add(projectFileFullPath)) { // This has already been processed or does not exist continue; } IReadOnlyList <ExternalProjectReference> cacheReferences; if (cache.TryGetValue(projectFileFullPath, out cacheReferences)) { // The cached value contains the entire closure, add it to the results and skip // all child references. results.UnionWith(cacheReferences); } else { // Get direct references var projectResult = GetDirectProjectReferences( dteReference.Project, projectFileFullPath, context, itemsFactory, rootProjectPath); // Add results to the closure results.UnionWith(projectResult.Processed); // Continue processing foreach (var item in projectResult.ToProcess) { toProcess.Push(item); } } } // Cache the results for this project and every child project which has not been cached foreach (var project in results) { if (!context.Cache.ContainsKey(project.UniqueName)) { var closure = BuildIntegratedRestoreUtility.GetExternalClosure(project.UniqueName, results); context.Cache.Add(project.UniqueName, closure.ToList()); } } return(cache[rootProjectPath]); }
public VsCommonOperations() : this(ServiceLocator.GetInstance <DTE>()) { }
/// <summary> /// Gets the VsSettings singleton object. /// </summary> /// <returns>The VsSettings object in the system.</returns> public static Configuration.ISettings GetVsSettings() { return(ServiceLocator.GetInstance <Configuration.ISettings>()); }
private async Task <(IPackageFeed?mainFeed, IPackageFeed?recommenderFeed)> CreatePackageFeedAsync( IReadOnlyCollection <IProjectContextInfo> projectContextInfos, IReadOnlyCollection <string> targetFrameworks, ItemFilter itemFilter, bool recommendPackages, IEnumerable <SourceRepository> sourceRepositories, CancellationToken cancellationToken) { var logger = new VisualStudioActivityLogger(); var uiLogger = ServiceLocator.GetInstance <INuGetUILogger>(); var packageFeeds = (mainFeed: (IPackageFeed?)null, recommenderFeed: (IPackageFeed?)null); if (itemFilter == ItemFilter.All && recommendPackages == false) { packageFeeds.mainFeed = new MultiSourcePackageFeed(sourceRepositories, uiLogger, TelemetryActivity.NuGetTelemetryService); return(packageFeeds); } IInstalledAndTransitivePackages installedAndTransitivePackages = await GetInstalledAndTransitivePackagesAsync(projectContextInfos, cancellationToken); PackageCollection installedPackageCollection = PackageCollection.FromPackageReferences(installedAndTransitivePackages.InstalledPackages); PackageCollection transitivePackageCollection = PackageCollection.FromPackageReferences(installedAndTransitivePackages.TransitivePackages); SourceRepository packagesFolderSourceRepository = await _packagesFolderLocalRepositoryLazy.GetValueAsync(cancellationToken); IEnumerable <SourceRepository> globalPackageFolderRepositories = await _globalPackageFolderRepositoriesLazy.GetValueAsync(cancellationToken); var metadataProvider = new MultiSourcePackageMetadataProvider( sourceRepositories, packagesFolderSourceRepository, globalPackageFolderRepositories, logger); if (itemFilter == ItemFilter.All) { // if we get here, recommendPackages == true packageFeeds.mainFeed = new MultiSourcePackageFeed(sourceRepositories, uiLogger, TelemetryActivity.NuGetTelemetryService); packageFeeds.recommenderFeed = new RecommenderPackageFeed( sourceRepositories, installedPackageCollection, transitivePackageCollection, targetFrameworks, metadataProvider, logger); return(packageFeeds); } if (itemFilter == ItemFilter.Installed) { packageFeeds.mainFeed = new InstalledPackageFeed(installedPackageCollection, metadataProvider, logger); return(packageFeeds); } if (itemFilter == ItemFilter.Consolidate) { packageFeeds.mainFeed = new ConsolidatePackageFeed(installedPackageCollection, metadataProvider, logger); return(packageFeeds); } // Search all / updates available cannot work without a source repo if (sourceRepositories == null) { return(packageFeeds); } if (itemFilter == ItemFilter.UpdatesAvailable) { packageFeeds.mainFeed = new UpdatePackageFeed( _serviceBroker, installedPackageCollection, metadataProvider, projectContextInfos.ToArray()); return(packageFeeds); } throw new InvalidOperationException( string.Format(CultureInfo.CurrentCulture, Strings.UnsupportedFeedType, itemFilter)); }
/// <summary> /// Get only the direct dependencies from a project /// </summary> public static async Task <IReadOnlyList <ProjectRestoreReference> > GetDirectProjectReferences( EnvDTEProject project, IEnumerable <string> resolvedProjects, ILogger log) { return(await NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() => { // DTE calls need to be done from the main thread await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var results = new List <ProjectRestoreReference>(); var itemsFactory = ServiceLocator.GetInstance <IVsEnumHierarchyItemsFactory>(); // Verify ReferenceOutputAssembly var excludedProjects = GetExcludedReferences(project, itemsFactory); var hasMissingReferences = false; // find all references in the project foreach (var childReference in GetProjectReferences(project)) { try { var reference3 = childReference as Reference3; // check if deferred projects resolved this reference, which means this is still not loaded so simply continue // We'll get this reference from deferred projects later if (reference3 != null && resolvedProjects.Contains(reference3.Name, StringComparer.OrdinalIgnoreCase)) { continue; } // Set missing reference if // 1. reference is null OR // 2. reference is not resolved which means project is not loaded or assembly not found. else if (reference3 == null || !reference3.Resolved) { // Skip missing references and show a warning hasMissingReferences = true; continue; } // Skip missing references if (childReference.SourceProject != null) { if (EnvDTEProjectUtility.HasUnsupportedProjectCapability(childReference.SourceProject)) { // Skip this shared project continue; } var childProjectPath = EnvDTEProjectInfoUtility.GetFullProjectPath(childReference.SourceProject); // Skip projects which have ReferenceOutputAssembly=false if (!string.IsNullOrEmpty(childProjectPath) && !excludedProjects.Contains(childProjectPath, StringComparer.OrdinalIgnoreCase)) { var restoreReference = new ProjectRestoreReference() { ProjectPath = childProjectPath, ProjectUniqueName = childProjectPath }; results.Add(restoreReference); } } } catch (Exception ex) { // Exceptions are expected in some scenarios for native projects, // ignore them and show a warning hasMissingReferences = true; log.LogDebug(ex.ToString()); Debug.Fail("Unable to find project dependencies: " + ex.ToString()); } } if (hasMissingReferences) { // Log a generic message once per project if any items could not be resolved. // In most cases this can be ignored, but in the rare case where the unresolved // item is actually a project the restore result will be incomplete. var message = string.Format( CultureInfo.CurrentCulture, Strings.UnresolvedItemDuringProjectClosureWalk, EnvDTEProjectInfoUtility.GetUniqueName(project)); log.LogVerbose(message); } return results; })); }
public VsProductUpdateSettings() : this(ServiceLocator.GetInstance <IServiceProvider>()) { }
public static async Task <bool> IsNuGetProjectUpgradeableAsync(NuGetProject nuGetProject, Project envDTEProject = null) { await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); if (nuGetProject == null && envDTEProject == null) { return(false); } if (nuGetProject == null) { var solutionManager = ServiceLocator.GetInstance <IVsSolutionManager>(); var projectSafeName = await EnvDTEProjectInfoUtility.GetCustomUniqueNameAsync(envDTEProject); nuGetProject = await solutionManager.GetNuGetProjectAsync(projectSafeName); if (nuGetProject == null) { return(false); } } // check if current project is packages.config based or not var msBuildNuGetProject = nuGetProject as MSBuildNuGetProject; if (msBuildNuGetProject == null || !msBuildNuGetProject.PackagesConfigNuGetProject.PackagesConfigExists()) { return(false); } // this further check if current project system supports VSProject4 or not which is essential to skip // projects like c++ which currently doesn't support VSProject4 implementation for PackageReference if (!msBuildNuGetProject.ProjectServices.Capabilities.SupportsPackageReferences) { return(false); } if (envDTEProject == null) { var vsmsBuildNuGetProjectSystem = msBuildNuGetProject.ProjectSystem as VsMSBuildProjectSystem; if (vsmsBuildNuGetProjectSystem == null) { return(false); } envDTEProject = vsmsBuildNuGetProjectSystem.VsProjectAdapter.Project; } if (!EnvDTEProjectUtility.IsSupported(envDTEProject)) { return(false); } var projectGuids = VsHierarchyUtility.GetProjectTypeGuids(envDTEProject); if (projectGuids.Any(t => UnupgradeableProjectTypes.Contains(t))) { return(false); } // Project is supported language, and not an unsupported type return(UpgradeableProjectTypes.Contains(envDTEProject.Kind) && projectGuids.All(projectTypeGuid => !SupportedProjectTypes.IsUnsupported(projectTypeGuid))); }
public VSSourceControlManagerProvider() : this(ServiceLocator.GetInstance <DTE>(), ServiceLocator.GetGlobalService <SComponentModel, IComponentModel>()) { }
public InteractiveLoginProvider() { _dte = ServiceLocator.GetInstance <DTE>(); }
/// <summary> /// Gets the VsSettings singleton object. /// </summary> /// <returns>The VsSettings object in the system.</returns> public static ISettings GetVsSettings() { return(ServiceLocator.GetInstance <ISettings>()); }