Beispiel #1
0
        public DiagnosticService(
            IAsynchronousOperationListenerProvider listenerProvider,
            [ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners
            )
        {
            // we use registry service rather than doing MEF import since MEF import method can have race issue where
            // update source gets created before aggregator - diagnostic service - is created and we will lose events fired before
            // the aggregator is created.
            _updateSources = ImmutableHashSet <IDiagnosticUpdateSource> .Empty;

            // queue to serialize events.
            _eventMap = new EventMap();

            _eventQueue = new TaskQueue(
                listenerProvider.GetListener(FeatureAttribute.DiagnosticService),
                TaskScheduler.Default
                );

            _gate = new object();
            _map  =
                new Dictionary <
                    IDiagnosticUpdateSource,
                    Dictionary <Workspace, Dictionary <object, Data> >
                    >();

            _eventListenerTracker = new EventListenerTracker <IDiagnosticService>(
                eventListeners,
                WellKnownEventListeners.DiagnosticService
                );
        }
 public TodoCommentIncrementalAnalyzerProvider(
     TodoCommentTokens todoCommentTokens,
     [ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners)
 {
     _todoCommentTokens    = todoCommentTokens;
     _eventListenerTracker = new EventListenerTracker <ITodoListProvider>(eventListeners, WellKnownEventListeners.TodoListProvider);
 }
        public VisualStudioTodoCommentsService(
            VisualStudioWorkspaceImpl workspace,
            IGlobalOptionService globalOptions,
            IThreadingContext threadingContext,
            IAsynchronousOperationListenerProvider asynchronousOperationListenerProvider,
            [ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners)
            : base(threadingContext)
        {
            _workspace            = workspace;
            _eventListenerTracker = new EventListenerTracker <ITodoListProvider>(eventListeners, WellKnownEventListeners.TodoListProvider);

            _listener = new TodoCommentsListener(
                globalOptions,
                workspace.Services,
                asynchronousOperationListenerProvider,
                onTodoCommentsUpdated: (documentId, oldComments, newComments) =>
            {
                if (TodoListUpdated != null && !oldComments.SequenceEqual(newComments))
                {
                    TodoListUpdated?.Invoke(
                        this, new TodoItemsUpdatedArgs(
                            documentId, _workspace, _workspace.CurrentSolution,
                            documentId.ProjectId, documentId, newComments));
                }
            },
                threadingContext.DisposalToken);
        }
 public VisualStudioTodoCommentsService(
     VisualStudioWorkspaceImpl workspace,
     IThreadingContext threadingContext,
     [ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners)
     : base(threadingContext)
 {
     _workspace            = workspace;
     _eventListenerTracker = new EventListenerTracker <ITodoListProvider>(eventListeners, WellKnownEventListeners.TodoListProvider);
 }
Beispiel #5
0
        public DiagnosticService(
            IAsynchronousOperationListenerProvider listenerProvider,
            [ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners) : this()
        {
            // queue to serialize events.
            _eventMap = new EventMap();

            _eventQueue = new TaskQueue(listenerProvider.GetListener(FeatureAttribute.DiagnosticService), TaskScheduler.Default);

            _gate = new object();
            _map  = new Dictionary <IDiagnosticUpdateSource, Dictionary <Workspace, Dictionary <object, Data> > >();

            _eventListenerTracker = new EventListenerTracker <IDiagnosticService>(eventListeners, WellKnownEventListeners.DiagnosticService);
        }
Beispiel #6
0
        public DiagnosticService(
            IAsynchronousOperationListenerProvider listenerProvider,
            [ImportMany] IEnumerable <Lazy <IEventListener, EventListenerMetadata> > eventListeners) : this()
        {
            // queue to serialize events.
            _eventMap = new EventMap();

            // use diagnostic event task scheduler so that we never flood async events queue with million of events.
            // queue itself can handle huge number of events but we are seeing OOM due to captured data in pending events.
            _eventQueue = new TaskQueue(listenerProvider.GetListener(FeatureAttribute.DiagnosticService), s_eventScheduler);

            _gate = new object();
            _map  = new Dictionary <IDiagnosticUpdateSource, Dictionary <Workspace, Dictionary <object, Data> > >();

            _eventListenerTracker = new EventListenerTracker <IDiagnosticService>(eventListeners, WellKnownEventListeners.DiagnosticService);
        }
Beispiel #7
0
 internal TestAccessor(EventListenerTracker <TService> eventListenerTracker)
 => _eventListenerTracker = eventListenerTracker;