コード例 #1
0
        ///// <summary>
        ///// Gets the service provider from the owner package.
        ///// </summary>
        //private Microsoft.VisualStudio.Shell.IAsyncServiceProvider ServiceProvider
        //{
        //    get
        //    {
        //        return this._package;
        //    }
        //}

        /// <summary>
        /// Initializes the singleton instance of the command.
        /// </summary>
        /// <param name="package">Owner package, not null.</param>
        public static async Task InitializeAsync(AsyncPackage package)
        {
            await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(package.DisposalToken);

            OleMenuCommandService commandService = (await package.GetServiceAsync((typeof(IMenuCommandService))) as OleMenuCommandService) !;

            Instance = new BindingListWindowCommand(package, commandService);
        }
コード例 #2
0
        /// <summary>
        /// Initialization of the package; this method is called right after the package is sited, so this is the place
        /// where you can put all the initialization code that rely on services provided by VisualStudio.
        /// </summary>
        /// <param name="cancellationToken">A cancellation token to monitor for initialization cancellation, which can occur when VS is shutting down.</param>
        /// <param name="progress">A provider for progress updates.</param>
        /// <returns>A task representing the async work of package initialization, or an already completed task if there is none. Do not return null from this method.</returns>
        protected override async Task InitializeAsync(
            CancellationToken cancellationToken,
            IProgress <ServiceProgressData> progress
            )
        {
            LogVS("Start 1");

            await base.InitializeAsync(cancellationToken, progress);

            LogVS("Start 2");

            // When initialized asynchronously, the current thread may be a background thread at this point.
            // Do any initialization that requires the UI thread after switching to the UI thread.
            await this.JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);

            await DpdtInstallCommand.InitializeAsync(this);

            await DoCreateClusterCommand.InitializeAsync(this);

            await BindingListWindowCommand.InitializeAsync(this);

            LogVS("Start 3");

            //we do not wait it for its completion.
            CodeLensConnectionHandler.AcceptCodeLensConnectionsAsync()
            .FileAndForget(nameof(CodeLensConnectionHandler.AcceptCodeLensConnectionsAsync))
            ;

            LogVS("Start 4");

            var container = (await this.GetServiceAsync(typeof(SComponentModel)) as IComponentModel) !;

            LogVS("Start 5");

            var bsc = container.GetService <BuildStatusContainer>();

            bsc.Subscribe();

            var solution = await this.GetServiceAsync(typeof(SVsSolution)) as IVsSolution;

            if (solution != null)
            {
                LogVS("Start 6");

                var sEventsExt0 = container.GetService <ExtensionStatusContainer>();
                foreach (var sEventExt in new[] { sEventsExt0 })
                {
                    uint cookie;
                    solution !.AdviseSolutionEvents(sEventExt, out cookie);

                    sEventExt.Cookie = cookie;
                }
            }

            LogVS("Start 7");

            var isc = container !.GetService <IntellisenseStatusContainer>();
            await isc.StartAsync();

            isc.StartScanningInThreadPool();

            LogVS("Start 8");
        }