Different Processes and OutputChannel issue

[GFlisch]

I am rewriting an old Visual Studio Extension to the new model.
I still need to use the AsyncPackage (concept) in a InProcComponent to catch a IVsSolutionEvents.
The remaining part of the code is in the OutOfProcComponent.

I use an OutputChannel to inform the user about what the extension is performing.
The InProcComponent is Notifying that a project is loaded (from IVsSolutionEvents) to the OutOfProcComponent and the notification code create an output channel to write a message. Everything is fine.

I have commands and when I use the same output channel, I see in the output window a double entry with the first messages but not the second.
By investigating I was able to identify that the components (In and Out) are running in a different process => the In doing the notification to the Out is running the code in one, so the CreateOutputChannelAsync (even via a Singleton pattern) is a specific instance and the commands executed only in the Out are running in another process => so another singleton instance is created.
As the code to create the output channel is the same and use the same name, I have a double entry in the output window of Visual Studio and new messages are not sent to one of the output channels.

My work around will be to create 2 different channels, but I would like to use one!

Any idea how to solve this?

[matteo-prosperi]

You could consider using the strategy described here to have a single brokered service on one side of the extension (either in-proc or out-of-proc) that does all the logging to the output window.

[GFlisch]

You can reproduce the existence of the 2 processes based on the example: https://github.com/microsoft/VSExtensibility/blob/main/New_Extensibility_Model/Samples/CompositeExtension/README.md

I have added the following code in the InProcService and OutOfProcService.

    public async Task DoSomethingAsync(CancellationToken cancellationToken)
    {
#pragma warning disable VSEXTPREVIEW_OUTPUTWINDOW // Use "Async" suffix for async methods
        var channel = await this.extensibility.Views().Output.CreateOutputChannelAsync("InProcComponent", cancellationToken);
        await channel.WriteLineAsync($"InProc => Pid = {Process.GetCurrentProcess().Id}, AppDomain = {AppDomain.CurrentDomain.Id} ");
#pragma warning enable VSEXTPREVIEW_OUTPUTWINDOW // Use "Async" suffix for async methods
        await this.extensibility.Shell().ShowPromptAsync("Hello from out-of-proc! (Showing this message from (in-proc)", PromptOptions.OK, cancellationToken);
    }

    public async Task DoSomethingAsync(CancellationToken cancellationToken)
    {
#pragma warning disable VSEXTPREVIEW_OUTPUTWINDOW // Use "Async" suffix for async methods
        var channel =await this.extensibility.Views().Output.CreateOutputChannelAsync("OutOfProcComponent", cancellationToken);
        await channel.WriteLineAsync($"OutOfProc => Pid = {Process.GetCurrentProcess().Id}, AppDomain = {AppDomain.CurrentDomain.Id} ");
#pragma warning enable VSEXTPREVIEW_OUTPUTWINDOW // Use "Async" suffix for async methods

        await this.extensibility.Shell().ShowPromptAsync("Hello from in-proc! (Showing this message from (out-of-proc)", PromptOptions.OK, cancellationToken);
    }

The output window gives:
InProcComponent
InProc => Pid = 18096, AppDomain = 1

OutOfProcComponent
OutOfProc => Pid = 23064, AppDomain = 1

=> So 2 different processes, with 2 different ServiceCollections instances for the OutOfProcComponent.

It is becoming difficult to keep some consistency in a same component. Any idea how to solve this?

[matteo-prosperi]

I'm not sure I follow. You said

So 2 different processes, with 2 different ServiceCollections instances for the OutOfProcComponent

But the output you posted indicates that one of the line is from InProcComponent, the other from OutOfProcComponent.

InProcComponent
InProc => Pid = 18096, AppDomain = 1

OutOfProcComponent
OutOfProc => Pid = 23064, AppDomain = 1

You can always opt to run everything out of process (if you don't need VSSDK features like AsyncPackage), or you can opt to run everything in-proc (and use a mix of VSSDK and VisualStudio.Extensibility features) as shown in this sample.

Using both an in-proc component and an out-of-proc component in the same extension is a more complicated choice that is only really needed if you need both VSSDK APIs and modern .NET (.NET 8) libraries.

[GFlisch]

Hi,

You're right. I was too fast and wrong and it is confusing.

I have adapted the code and output the process id when executing an OutOfProcComponent command.

    public override async Task ExecuteCommandAsync(IClientContext context, CancellationToken cancellationToken)
    {
#pragma warning disable VSEXTPREVIEW_OUTPUTWINDOW 
        var channel = await this.Extensibility.Views().Output.CreateOutputChannelAsync("Command", cancellationToken);
        await channel.WriteLineAsync($"Command => Pid = {Process.GetCurrentProcess().Id}, AppDomain = {AppDomain.CurrentDomain.Id} ");
#pragma warning enable VSEXTPREVIEW_OUTPUTWINDOW // Use "Async" suffix for async methods
        var inProcService = await this.Extensibility.ServiceBroker.GetProxyAsync<IOutOfProcService>(IInProcService.Configuration.ServiceDescriptor, cancellationToken);
        try
        {
            Assumes.NotNull(inProcService);
            await inProcService.DoSomethingAsync(cancellationToken);
        }
        finally
        {
            (inProcService as IDisposable)?.Dispose();
        }
    }

OutOfProc => Pid = 1888, AppDomain = 1
Command => Pid = 12828, AppDomain = 1

So, as you can see, the OutOfProc Process Id is the id when a Notification is raised from an InProc notification (but executed in the OutOfProcComponent) and the Command is the process id when the command is executed from the OutOfProc command.

We have 2 different processes; I was expecting the notification issued from the InProc is serialized and executed by the same OutOfProcComponent process.

[GFlisch]

Hi @matteo-prosperi, did you had time to check the new comment?
Thanks in advance.