How to write a Visual Studio extension that injects environment variables into a .NET 4.8 application on debug launch

Thank you for reaching out. Please find the answer below.

Correct Way to Inject Environment Variables into .NET Framework Debug Launches

Why IVsDebugLaunchTargetProvider2 Doesn’t Work

That interface is only used by the generic launcher (CMake, Open Folder, launch.vs.json projects).
Classic .NET Framework (.csproj) projects bypass it entirely and call the Managed debug engine directly.
So, your SetupDebugTargetInfo will never fire, no matter what DebuggerTemplate string you try.

The Two Supported Approaches

Option A: Implement a Launch Settings Provider

For projects that use CPS (including some managed projects in newer VS SDKs), you can hook into debug launch by implementing IVsDebugLaunchSettingsProvider:

[Export(typeof(IVsDebugLaunchSettingsProvider))]
[AppliesTo(ProjectCapability.CSharp)] // scope to C# projects
public class EnvVarLaunchSettingsProvider : IVsDebugLaunchSettingsProvider
{
    public Task> GetLaunchSettingsAsync(DebugLaunchOptions launchOptions)
    {
        var settings = new DebugLaunchSettings(launchOptions)
        {
            Environment = new Dictionary
            {
                { "MYFLAG", "1" },
                { "FOO", "BAR" }
            }
        };

        return Task.FromResult>(new[] { settings });
    }
}

Visual Studio will merge these into the process environment before launching.

Option B: Modify the Debug Tab’s Environment Property

Every .NET Framework project already has a Debug property called Environment (visible in Project Properties → Debug).
You can programmatically set this from your extension:

var dte = (DTE2)ServiceProvider.GlobalProvider.GetService(typeof(DTE));
var proj = dte.Solution?.Projects?.Item(1); // your startup project
var config = proj.ConfigurationManager.ActiveConfiguration;

// Set environment variables (semicolon-separated)

Visual Studio automatically merges these into the debugged process’ environment.

Debugging & Testing Your Extension

• Run Visual Studio with /rootsuffix Exp to start an experimental instance.
• Attach to devenv.exe and put breakpoints in your provider/property code.
• Press F5 on a .NET Framework app and verify your environment variables appear.

Bottom Line

• Use IVsDebugLaunchSettingsProvider if you want to inject dynamically at launch.
• Use the project’s Environment property if you want a persistent, configuration-based approach.
• Don’t waste time trying to guess a DebuggerTemplate — it’s not used for .NET Framework .csproj debugging.

Let us know if you need further help with this. We'll be happy to assist.

No — IVsDebugLaunchTargetProvider2 is not used by the built-in .NET Framework debugger, so your export will never get picked up. The debuggerTemplate string is only for custom debuggers, not the default managed one.

For injecting env vars into .NET Framework apps, the supported approach is to implement IVsDebugLaunchSettingsProvider (or IDebugLaunchProvider in newer APIs) and modify the VsDebugTargetInfo4 before launch. Alternatively, a DebugLaunchProvider via IVsDebugLaunchSettingsProvider MEF is the right extensibility point—not.IVsDebugLaunchTargetProvider2

Thank you for reaching out. Please find the answer below.
Yes, your method is correct.

To inject environment variables into a .NET Framework 4.8 application during debug launch using a Visual Studio 2022 extension, you should implement the IVsDebugLaunchTargetProvider2 interface and export it using the ExportVsDebugLaunchTarget2Attribute. This allows you to modify the VsDebugTargetInfo4 structure, including setting the bstrEnv field with your desired environment variables.

The key detail is the debuggerTemplate string you supply in the attribute. If it doesn’t match the template used by the .NET Framework project system, your provider won’t be invoked. Try using "Managed" or "ManagedOnly" these are commonly used for .NET Framework debugging. If those don’t work, you may need to inspect the project system or use diagnostic logging to determine the correct template.

To confirm your extension is working:

• Add logging or breakpoints in your SetupDebugTargetInfo method.
• Use devenv /log to check Visual Studio’s Activity Log for MEF composition issues.
• Ensure your extension is properly loaded and your provider is being discovered.

This method aligns with Visual Studio extensibility practices and should work once the correct debuggerTemplate is matched.