/// <summary> /// Implements the OnDisconnection method of the IDTExtensibility2 interface. /// Occurs when he Add-in is loaded into Visual Studio. /// </summary> /// <param name="application">A reference to an instance of the IDE, DTE.</param> /// <param name="connectMode"> /// An <see cref="ext_ConnectMode"/> enumeration value that indicates /// the way the add-in was loaded into Visual Studio. /// </param> /// <param name="instance">An <see cref="AddIn"/> reference to the add-in's own instance.</param> /// <param name="custom">An empty array that you can use to pass host-specific data for use in the add-in.</param> public void OnConnection(object application, ext_ConnectMode connectMode, object instance, ref Array custom) { App = (DTE2)application; Instance = (AddIn)instance; Events = App.Events as Events2; Logger = new OutputWindowLogger(App); Logger.Log("Loading..."); Compose(); // Do not attempt to use [Import]s before this line! if (Chirp == null) { Logger.Log("Unable to load."); return; } BindEvents(); PrintLoadedEngines(); Logger.Log("Ready"); if (App.Solution.IsOpen) { SolutionOpened(); foreach (var project in App.Solution.Projects.Cast <Project>()) { ProjectAdded(project); } } }
public async System.Threading.Tasks.Task HandleChangeAsync(IWpfTextView textView) { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); try { var profiler = MiniProfiler.StartNew(nameof(HandleChangeAsync)); profiler.Storage = new NLogStorage(LogManager.GetLogger("profiler")); using (profiler.Step("HandleChangeCode")) { SnapshotPoint caretPosition = textView.Caret.Position.BufferPosition; Microsoft.CodeAnalysis.Document roslynDocument = caretPosition.Snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (roslynDocument == null) { OutputWindowLogger.WriteLn($"Unable to get c# file to process. Name {caretPosition.Snapshot.ContentType.DisplayName}"); return; } await GotoAsyncPackage.Storage.AnalyzeAndUpdateSingleAsync(roslynDocument); } } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "CSharpFileContentOnChange.HandleChange"); OutputWindowLogger.WriteLn($"Exception occured during handling csharp file change: {ex.Message}"); } }
/// <summary> /// Implements the OnDisconnection method of the IDTExtensibility2 interface. /// Occurs when he Add-in is loaded into Visual Studio. /// </summary> /// <param name="application">A reference to an instance of the IDE, DTE.</param> /// <param name="connectMode"> /// An <see cref="ext_ConnectMode"/> enumeration value that indicates /// the way the add-in was loaded into Visual Studio. /// </param> /// <param name="instance">An <see cref="AddIn"/> reference to the add-in's own instance.</param> /// <param name="custom">An empty array that you can use to pass host-specific data for use in the add-in.</param> public void OnConnection(object application, ext_ConnectMode connectMode, object instance, ref Array custom) { App = (DTE2) application; Instance = (AddIn) instance; Events = App.Events as Events2; Logger = new OutputWindowLogger(App); Logger.Log("Loading..."); Compose(); // Do not attempt to use [Import]s before this line! if(Chirp == null) { Logger.Log("Unable to load."); return; } BindEvents(); PrintLoadedEngines(); Logger.Log("Ready"); if(App.Solution.IsOpen) { SolutionOpened(); foreach (var project in App.Solution.Projects.Cast<Project>()) { ProjectAdded(project); } } }
private MapProcessingResult HandleMaps(ConfigProcessingResult configProcessingResult) { var xmlFiles = DocumentHelper.GetXmlFiles(_projectItems); var configs = GotoAsyncPackage.Storage.SqlMapConfigProvider.GetAll(); if (_options.MapsOptions.IndexAllMaps) { return(HandleCorrectMapFiles(xmlFiles, configs)); } if (_options.MapsOptions.IndexOnlyMapsInConfig) { var fileNames = configs.SelectMany(e => e.Maps).Select(e => e.Value); var filteredXmlFiles = GetExistingInMaps(xmlFiles, fileNames); if (fileNames.Any(e => e.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)) { //Fallback scenario, when path/filename is invaild than just index all maps in solution, //maps that are are not referenced in config, will be assigned to default config. OutputWindowLogger.WriteLn("Found invaild character for file. Parsing all maps found in solution."); return(HandleAllMapFiles(xmlFiles, configs)); } return(HandleCorrectMapFiles(filteredXmlFiles, configs)); } return(new MapProcessingResult()); }
private IEnumerable <SqlMapConfig> GetConfigs(IEnumerable <ProjectItem> projectItems) { var configs = GetConfigsFiles(projectItems); OutputWindowLogger.WriteLn($"Found config candidates: {string.Join(" ", configs.Select(e=>e.FilePath))}"); var parsedConfigs = configs.Select(config => _xmlIndexer.ParseSingleConfigFile(config)).Where(e => e.ParsedSuccessfully); OutputWindowLogger.WriteLn($"Parsed configs: {string.Join(" ", parsedConfigs.Select(e=>e.Name))}"); return(parsedConfigs); }
public void ShouldWriteInOutputWindow() { MockOutputWindow mockVsOutputWindow = new MockOutputWindow(); OutputWindowLogger logger = new OutputWindowLogger(mockVsOutputWindow); logger.Log("test"); Assert.IsTrue(mockVsOutputWindow.GetPaneCalled); Assert.AreEqual(ProjectLinkerGuids.GuidProjectLinkerOutputPane, mockVsOutputWindow.GetPaneArgumentGuidPane); StringAssert.Contains(mockVsOutputWindow.GetPaneReturnValue.OutputStringThreadSafeArgumentString, "test"); }
public void ItemRenamed(ProjectItem ProjectItem, string OldName) { try { Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); GotoAsyncPackage.Storage.CodeQueries.RenameStatmentsForFile(OldName, ProjectItem.Name); GotoAsyncPackage.Storage.XmlQueries.RenameStatmentsForFile(OldName, ProjectItem.Name); } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "ProjectItemEventsEx.ItemRenamed"); OutputWindowLogger.WriteLn($"Exception occured during ProjectItemEventsEx.ItemRenamed: { ex.Message}"); } }
public int OnAfterBackgroundSolutionLoadComplete() { Debug.WriteLine("OnAfterBackgroundSolutionLoadComplete()"); try { //Load Xml files from indexer _actions.OnSolutionLoadComplete(); } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "SolutionEventsHandler.OnAfterBackgroundSolutionLoadComplete"); OutputWindowLogger.WriteLn($"Exception occured during SolutionEventsHandler.OnAfterBackgroundSolutionLoadComplete: { ex.Message}"); } return(VSConstants.S_OK); }
public override void MenuItemCallback(object sender, EventArgs e) { try { _documentProcessor.TryResolveQueryValueAtCurrentSelectedLine(out ExpressionResult expressionResult, out string queryValue); _finalActionFactory .GetFinalRenameQueryActionsExecutor(StatusBar, _commandWindow, GotoAsyncPackage.EnvDTE, Package.Workspace) .Execute(queryValue, expressionResult); } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "QueryRenameActions.MenuItemCallback"); OutputWindowLogger.WriteLn($"Exception occured during QueryRenameActionsMenuCallback: {ex.Message}"); } }
public void ValidateAllSpans() { try { foreach (var validator in _validators) { (validator as IBufferValidator).ValidateAllSpans(); } } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "XmlValidatorsAggregator.ValidateAllSpans"); OutputWindowLogger.WriteLn($"Exception occured during XmlValidatorsAggregator.ValidateAllSpans: { ex.Message}"); } }
public int OnQueryCloseSolution(object pUnkReserved, ref int pfCancel) { try { //Remove everything from indexer instance _actions.SolutionOnClose(); //Remove Errors TableDataSource.Instance.CleanAllErrors(); } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "SolutionEventsHandler.OnQueryCloseSolution"); OutputWindowLogger.WriteLn($"Exception occured during SolutionEventsHandler.OnQueryCloseSolution: { ex.Message}"); } return(1); }
/// <summary> /// Initializes a new instance of the <see cref="InliningAnalyzerCommands"/> class. /// Adds our command handlers for menu (commands must exist in the command table file) /// </summary> private async Task InitializeAsync() { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var dte2 = (DTE2)Package.GetGlobalService(typeof(SDTE)); _serviceProvider = new ServiceProvider(dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); var container = await _package.GetServiceAsync(typeof(Microsoft.VisualStudio.ComponentModelHost.SComponentModel)) as Microsoft.VisualStudio.ComponentModelHost.IComponentModel; container.DefaultCompositionService.SatisfyImportsOnce(this); _outputLogger = new OutputWindowLogger(_package); _statusBarLogger = new StatusBarLogger(_package); OleMenuCommandService commandService = await _package.GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService; if (commandService != null) { OleMenuCommand startMenuItem = new OleMenuCommand(StartMenuItemCallback, new CommandID(CommandSet, StartCommandId)); startMenuItem.BeforeQueryStatus += OnBeforeQueryStatusProject; startMenuItem.Enabled = dte2.Solution.IsOpen; commandService.AddCommand(startMenuItem); OleMenuCommand startForAssemblyMenuItem = new OleMenuCommand(StartForAssemblyMenuItemCallback, new CommandID(CommandSet, StartForAssemblyCommandId)); startForAssemblyMenuItem.BeforeQueryStatus += OnBeforeQueryStatusEnabled; startForAssemblyMenuItem.Enabled = dte2.Solution.IsOpen; commandService.AddCommand(startForAssemblyMenuItem); OleMenuCommand menuItem = new OleMenuCommand(ToggleMenuItemCallback, new CommandID(CommandSet, ToggleCommandId)); menuItem.BeforeQueryStatus += OnBeforeQueryStatusToggle; menuItem.Enabled = dte2.Solution.IsOpen; commandService.AddCommand(menuItem); OleMenuCommand optionsMenuItem = new OleMenuCommand(OpenOptionsCallback, new CommandID(CommandSet, OpenOptionsCommandId)); commandService.AddCommand(optionsMenuItem); OleMenuCommand contextMenuItem = new OleMenuCommand(StartForScopeMenuItemCallback, new CommandID(CommandSetContextMenu, StartForScopeCommandId)); contextMenuItem.BeforeQueryStatus += OnBeforeQueryStatusEnabled; contextMenuItem.Enabled = dte2.Solution.IsOpen; commandService.AddCommand(contextMenuItem); } }
public override void MenuItemCallback(object sender, EventArgs e) { try { var profiler = MiniProfiler.StartNew($"{nameof(GoToQueryActions2)}.{nameof(MenuItemCallback)}"); profiler.Storage = new NLogStorage(LogManager.GetLogger("profiler")); using (profiler.Step("Event start")) { _documentProcessor.TryResolveQueryValueAtCurrentSelectedLine(out ExpressionResult expressionResult, out string queryValue); _finalActionFactory .GetFinalGoToQueryActionsExecutor(StatusBar, _commandWindow, MapNamespaceHelper.IsQueryWithNamespace(queryValue)) .Execute(queryValue, expressionResult); } } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "GoToQuery.MenuItemCallback"); OutputWindowLogger.WriteLn($"Exception occured during GoToActionMenuCallback: {ex.Message}"); } }
public async Task <List <CSharpIndexerResult> > BuildIndexerAsync(List <Document> documents) { var results = new List <CSharpIndexerResult>(); Stopwatch sw = new Stopwatch(); sw.Start(); foreach (var document in documents) { if (!Regex.IsMatch(document.FilePath, @"(\\service|\\TemporaryGeneratedFile_.*|\\assemblyinfo|\\assemblyattributes|\.(g\.i|g|designer|generated|assemblyattributes))\.(cs|vb)$")) { results.Add(await BuildFromDocumentAsync(document)); } } sw.Stop(); await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); OutputWindowLogger.WriteLn($"Building Queries db from code ended in {sw.ElapsedMilliseconds} ms. Found {results.Count} queries. In {documents.Count} documents."); return(results); }
public void OnBuildBegin(vsBuildScope Scope, vsBuildAction Action) { try { ThreadHelper.ThrowIfNotOnUIThread(); var projectItemHelper = new ProjectItemRetreiver(GotoAsyncPackage.EnvDTE); var projectItems = projectItemHelper.GetProjectItemsFromSolutionProjects(); foreach (var xmlFile in DocumentHelper.GetXmlFiles(projectItems)) { var validator = XmlValidatorsAggregator.Create.AllValidatorsForBuild(xmlFile.FilePath); validator.ValidateBuildDocument(); validator.AddToErrorList(); } } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "BuildEvents.OnBuildBegin"); OutputWindowLogger.WriteLn($"Exception occured during BuildEvents.OnBuildBegin: { ex.Message}"); } }
public void ItemAdded(ProjectItem ProjectItem) { try { Microsoft.VisualStudio.Shell.ThreadHelper.ThrowIfNotOnUIThread(); string projectItemExtension = Path.GetExtension(ProjectItem.Name); if (projectItemExtension == ".xml") { GotoAsyncPackage.Storage.AnalyzeAndStoreSingle(new XmlFileInfo { FilePath = ProjectItem.FileNames[0], ProjectName = ProjectItem.ContainingProject.Name }); } } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "ProjectItemEventsEx.ItemAdded"); OutputWindowLogger.WriteLn($"Exception occured during ProjectItemEventsEx.ItemAdded: { ex.Message}"); } }
#pragma warning restore CS0649 /// <summary> /// Initializes a new instance of the <see cref="InliningAnalyzerCommands"/> class. /// Adds our command handlers for menu (commands must exist in the command table file) /// </summary> /// <param name="package">Owner package, not null.</param> private InliningAnalyzerCommands(Package package) { if (package == null) { throw new ArgumentNullException("package"); } var dte2 = (DTE2)Package.GetGlobalService(typeof(SDTE)); var sp = new ServiceProvider(dte2 as Microsoft.VisualStudio.OLE.Interop.IServiceProvider); var container = sp.GetService(typeof(Microsoft.VisualStudio.ComponentModelHost.SComponentModel)) as Microsoft.VisualStudio.ComponentModelHost.IComponentModel; container.DefaultCompositionService.SatisfyImportsOnce(this); _package = package; _outputLogger = new OutputWindowLogger(package); _statusBarLogger = new StatusBarLogger(package); OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService; if (commandService != null) { OleMenuCommand startMenuItem = new OleMenuCommand(StartMenuItemCallback, new CommandID(CommandSet, StartCommandId)); startMenuItem.BeforeQueryStatus += OnBeforeQueryStatusStart; startMenuItem.Enabled = dte2.Solution.IsOpen; commandService.AddCommand(startMenuItem); OleMenuCommand menuItem = new OleMenuCommand(ToggleMenuItemCallback, new CommandID(CommandSet, ToggleCommandId)); menuItem.BeforeQueryStatus += OnBeforeQueryStatusToggle; menuItem.Enabled = dte2.Solution.IsOpen; commandService.AddCommand(menuItem); OleMenuCommand optionsMenuItem = new OleMenuCommand(OpenOptionsCallback, new CommandID(CommandSet, OpenOptionsCommandId)); commandService.AddCommand(optionsMenuItem); OleMenuCommand contextMenuItem = new OleMenuCommand(StartForScopeMenuItemCallback, new CommandID(CommandSetContextMenu, StartForScopeCommandId)); contextMenuItem.Enabled = dte2.Solution.IsOpen; commandService.AddCommand(contextMenuItem); } }
public async System.Threading.Tasks.Task HandleChangeAsync(IWpfTextView textView) { try { await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); var profiler = MiniProfiler.StartNew(nameof(HandleChangeAsync)); profiler.Storage = new NLogStorage(LogManager.GetLogger("profiler")); using (profiler.Step("HandleChangeXml")) { var snapshot = textView.Caret.Position.BufferPosition.Snapshot; ITextDocument textDoc; textView.TextBuffer.Properties.TryGetProperty(typeof(ITextDocument), out textDoc); using (var stringReader = new StringReader(snapshot.GetText())) { var project = GotoAsyncPackage.EnvDTE.Solution.FindProjectItem(textDoc.FilePath)?.ContainingProject?.Name; XmlParser baseParser = new XmlParser(stringReader).Load(); if (baseParser.BatisXmlFileType == BatisXmlFileTypeEnum.SqlMap) { BatisXmlMapParser parser = new BatisXmlMapParser(baseParser).WithFileInfo(textDoc.FilePath, project); var newStatments = parser.GetMapFileStatments(); GotoAsyncPackage.Storage.XmlQueries.UpdateStatmentForFileWihoutKey(newStatments); } if (baseParser.BatisXmlFileType == BatisXmlFileTypeEnum.SqlMapConfig) { BatisXmlConfigParser parser = new BatisXmlConfigParser(baseParser).WithFileInfo(textDoc.FilePath, project); GotoAsyncPackage.Storage.SqlMapConfigProvider.UpdateOrAddConfig(parser.Result); } } } } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "XmlFileContentOnChange.HandleChange"); OutputWindowLogger.WriteLn($"Exception occured during handling xml file change: {ex.Message}"); } }
public List <Statement> BuildIndexer(IDictionary <SqlMapConfig, IEnumerable <XmlFileInfo> > configFileInfosPairs) { var result = new List <Statement>(); Stopwatch sw = new Stopwatch(); sw.Start(); foreach (var configFilesPair in configFileInfosPairs) { foreach (var xmlSolutionDocument in configFilesPair.Value) { BatisXmlMapParser parser = new BatisXmlMapParser().WithFileInfo(xmlSolutionDocument.FilePath, xmlSolutionDocument.ProjectName).Load(); bool isBatisQueryXmlFile = parser.XmlNamespace == XmlMapConstants.XmlNamespace; if (isBatisQueryXmlFile) { result.AddRange(parser.GetMapFileStatments()); } } } sw.Stop(); OutputWindowLogger.WriteLn($"Building Queries db from xml ended in {sw.ElapsedMilliseconds} ms. Found {result.Count} queries."); return(result); }
public virtual LoggingWireup UseOutputWindow() { OutputWindowLogger.MakePrimaryLogger(); return(this); }
public async System.Threading.Tasks.Task WorkspaceChangedAsync(object sender, WorkspaceChangeEventArgs e) { var profiler = MiniProfiler.StartNew(nameof(WorkspaceChangedAsync)); profiler.Storage = new NLogStorage(LogManager.GetLogger("profiler")); var workspace = sender as VisualStudioWorkspace; switch (e.Kind) { case WorkspaceChangeKind.SolutionAdded: try { using (profiler.Step(WorkspaceChangeKind.SolutionAdded.ToString())) { await _indexingQueue.EnqueueMultipleAsync(workspace.CurrentSolution.Projects); } } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "WorkspaceChangeKind.SolutionAdded"); await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); OutputWindowLogger.WriteLn($"Exception occured during adding solution: {ex.Message}"); } break; case WorkspaceChangeKind.SolutionChanged: break; case WorkspaceChangeKind.SolutionRemoved: break; case WorkspaceChangeKind.SolutionCleared: break; case WorkspaceChangeKind.SolutionReloaded: break; case WorkspaceChangeKind.ProjectAdded: try { using (profiler.Step(WorkspaceChangeKind.SolutionAdded.ToString())) { await _indexingQueue.EnqueueMultipleAsync(workspace.CurrentSolution.Projects); } } catch (Exception ex) { LogManager.GetLogger("error").Error(ex, "WorkspaceChangeKind.ProjectAdded"); OutputWindowLogger.WriteLn($"Exception occured during adding projects: {ex.Message}"); } break; case WorkspaceChangeKind.ProjectRemoved: break; case WorkspaceChangeKind.ProjectChanged: break; case WorkspaceChangeKind.ProjectReloaded: break; case WorkspaceChangeKind.DocumentAdded: var documentAddedChanges = e.NewSolution.GetChanges(e.OldSolution); var addedDocuments = documentAddedChanges.GetProjectChanges() .SelectMany(x => x.GetAddedDocuments()) .Select(x => workspace.CurrentSolution.GetDocument(x)); await DocumentsAddedActionAsync(addedDocuments); break; case WorkspaceChangeKind.DocumentRemoved: var documentRemovedChanges = e.NewSolution.GetChanges(e.OldSolution); var removedDocuments = documentRemovedChanges.GetProjectChanges() .SelectMany(x => x.GetRemovedDocuments()); await DocumentRemovedActionAsync(removedDocuments); break; case WorkspaceChangeKind.DocumentReloaded: break; case WorkspaceChangeKind.DocumentChanged: break; case WorkspaceChangeKind.AdditionalDocumentAdded: break; case WorkspaceChangeKind.AdditionalDocumentRemoved: break; case WorkspaceChangeKind.AdditionalDocumentReloaded: break; case WorkspaceChangeKind.AdditionalDocumentChanged: break; default: break; } await profiler.StopAsync(); }
/// <summary> /// /// </summary> protected override void Initialize() { base.Initialize(); InitializeDTE(); LogLevel logLevel = LogLevel.Info; if (Debugger.IsAttached) { logLevel = LogLevel.Verbose; } logger = new OutputWindowLogger(dte, "TFS Productivity Pack", logLevel); try { logger.Log("TFSProductivityPackage Initialize", LogLevel.Info); commandService = GetService(typeof(IMenuCommandService)) as OleMenuCommandService; ITFSConnection tfsConnection = new TFSConnection(dte, logger); ITFSVersionControl tfsVersionControl = new TFSVersionControl(tfsConnection, dte, logger); ITFSBuildService tfsBuildService = new TFSBuildService(tfsConnection, this, logger); //showDeletedFilesCmd = new ToggleShowDeletedItemsCommand( // commandService, // logger, // tfsVersionControl); quickCompareCmd = new TFSQuickCompareCommand( commandService, logger, tfsVersionControl); findInSCEFromSolExpCmd = new FindInSCEFromSolExpCommand( commandService, logger, dte, tfsVersionControl); findInSCEFromCodeWindowCmd = new FindInSCEFromCodeWindowCommand( commandService, logger, dte, tfsVersionControl); findInSolExpFromCodeWindowCmd = new FindInSolExpFromCodeWindowCommand( commandService, logger, dte); compareToBranchCommand = new CompareToBranchCommand( commandService, logger, tfsVersionControl); branchBuildDefinitionCmd = new BranchBuildDefinitionCommand( commandService, logger, tfsBuildService, tfsVersionControl); CommandID comapreToBranchMenuID = new CommandID(GuidList.guidTFSProductivityPackCmdSet, PkgCmdIDList.menuIdCompareToBranchMenu); OleMenuCommand menuItem = new OleMenuCommand(null, comapreToBranchMenuID); menuItem.BeforeQueryStatus += compareToBranchCommand.ParentMenuQueryStatus; commandService.AddCommand(menuItem); } catch (Exception ex) { logger.Log(string.Format("Error initializing TFsProductivityPackage\n {0}", ex.ToString()), LogLevel.Error); } }
public OutputWindowLoggerTests() { _underTest = new OutputWindowLogger(Mock.Of <IOutputPaneProvider>(p => p.Get() == _pane.Object)); }
protected override async System.Threading.Tasks.Task InitializeAsync(CancellationToken cancellationToken, IProgress <ServiceProgressData> progress) { NLogConfigurationService.ConfigureNLog(); NLogConfigurationService.ConfigureMiniProfilerWithDefaultLogger(); Logger logger = LogManager.GetLogger("error"); logger.Info("Extension initalizing"); EnvDTE = await GetServiceAsync(typeof(DTE)) as DTE2; Assumes.Present(EnvDTE); DteSemaphore.Release(); Storage = new PackageStorage(); var componentModel = await GetServiceAsync(typeof(SComponentModel)) as IComponentModel; Assumes.Present(componentModel); //Initialize public components, initialize instances that are dependent on any component TextManager = await GetServiceAsync(typeof(SVsTextManager)) as IVsTextManager; EditorAdaptersFactory = componentModel.GetService <IVsEditorAdaptersFactoryService>(); DocumentNavigationInstance.InjectDTE(EnvDTE); //Prepare package events var indexingQueue = new ProjectIndexingQueue(); var workspaceEvents = new WorkspaceEvents(indexingQueue); Workspace = componentModel.GetService <VisualStudioWorkspace>(); Workspace.WorkspaceChanged += (s, e) => ThreadHelper.JoinableTaskFactory.RunAsync(async() => await workspaceEvents.WorkspaceChangedAsync(s, e)); var indexingWorkflow = new IndexingWorkflow(Storage.IndexingWorkflowOptions, new ProjectItemRetreiver(EnvDTE), Storage); _envDteEvents = EnvDTE.Events as Events2; if (_envDteEvents != null) { ProjectItemEventsActions projectItemEvents = new ProjectItemEventsActions(); _envDteProjectItemsEvents = _envDteEvents.ProjectItemsEvents; _envDteProjectItemsEvents.ItemAdded += projectItemEvents.ItemAdded; _envDteProjectItemsEvents.ItemRemoved += projectItemEvents.ItemRemoved; _envDteProjectItemsEvents.ItemRenamed += projectItemEvents.ItemRenamed; EventHandlers.BuildEventsActions buildEvents = new EventHandlers.BuildEventsActions(); _buildEvents = _envDteEvents.BuildEvents; _buildEvents.OnBuildBegin += buildEvents.OnBuildBegin; } var solutionEventsActions = new VSSolutionEventsActions(indexingWorkflow); await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); await ResultWindowCommand.InitializeAsync(this); OutputWindowLogger.Init(await GetServiceAsync(typeof(SVsOutputWindow)) as SVsOutputWindow); IStatusBar = await GetServiceAsync(typeof(SVsStatusbar)) as IVsStatusbar; var svsSolution = await GetServiceAsync(typeof(SVsSolution)); Solution = svsSolution as IVsSolution; Assumes.Present(Solution); await HandleSolutionAsync(svsSolution, solutionEventsActions, indexingQueue); _solutionEventsHandler = new SolutionEventsHandler(solutionEventsActions); Solution.AdviseSolutionEvents(_solutionEventsHandler, out _solutionEventsCookie); await Goto.InitializeAsync(this); await RenameModalWindowCommand.InitializeAsync(this); await RenameCommand.InitializeAsync(this); await PrettyPrintCommand.InitializeAsync(this); }