JetBrains Rider
 
2024.3
Shortcuts: Visual Studio 2022 (Windows)
Get JetBrains Rider
  1. Languages and frameworks
  2. ASP.NET
  3. Run and debug .NET Core and ASP.NET Core apps with launch profiles

Run and debug .NET Core and ASP.NET Core apps with launch profiles

Last modified: 12 December 2024

A .NET Core or ASP.NET Core application can have its launch profiles configured with launchSettings.json. These profiles are auto-imported to the corresponding run/debug configurations, which you can then use to run and debug the application. Launch settings profiles for ASP.NET Core apps are often used to run and debug these apps in IIS Express.

What is launchSettings.json

launchSettings.json, which is placed in the Properties folder of a project, describes how the application can be launched — the command to execute, whether the browser should be opened, which environment variables should be set, and so on. This information can then be used by JetBrains Rider, by dotnet run, or by any other tool to run or debug the application.

This article details the conventions used in launchSettings.json. The example below shows a sample launchSettings.json with two launch profiles: IIS Express and Sample.

{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:43347",
      "sslPort": 44364
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "Sample": {
      "commandName": "Project",
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Staging"
      }
    }
  }
}

Create run/debug configurations based on launchSettings.json

When you open a project with launchSettings.json for the first time, JetBrains Rider will pick the available launch profiles and automatically create corresponding run/debug configurations, which you can then use to run and debug the project.

For example, after cloning and opening the Orchard CMS, JetBrains Rider will create the following run/debug configurations from the launchSettings.json files:

JetBrains Rider: Creating run/debug configurations based on launchSettings.json

JetBrains Rider only generates run/debug configurations automatically when no run configurations were created in the solution before. If there are existing run/debug configurations or if you remove the auto-generated configurations, you can right-click launchSettings.json in the Solution Explorer and choose Generate Configurations to import the project's launch profiles into run/debug configurations.

Run and debug launch profiles

When launch profiles are imported as run/debug configurations, you can choose the corresponding configuration on the toolbar and click Run Run or Debug Debug:

JetBrains Rider: Running a launch profile based launchSettings.json

If a project has launchSettings.json, but there are no corresponding run/debug configurations, you can right-click the project in the Solution Explorer and choose Run '...' or Debug '...'. In this case, JetBrains Rider will create a temporary run/debug configuration for the first launch profile in the project's launchSettings.json and execute it.

You can also open a launchSettings.json in the editor and use the gutter icons to run or debug any launch profile:

JetBrains Rider: Running a launch profile from launchSettings.json file

In this case, JetBrains Rider will also create a temporary run/debug configuration for this profile.

Edit launch settings profiles

A run/debug configurations based on a launch profile includes two kinds of parameters:

  • Parameters from launchSettings.json, which you can configure by editing the file — use syntax highlighting, code analysis, and code completion when editing:

    JetBrains Rider: Coding assistance for editing launchSettings.json

  • Additional configuration parameters added by JetBrains Rider, such as the target framework to use or .NET runtime arguments. To configure these parameters, choose Run | Edit Configurations from the menu and pick the corresponding configuration.

    Parameters from launchSettings.json are shown as read-only; all other parameters are editable:

    JetBrains Rider: Editing run/debug configuration based on launchSettings.json

Preferences of the '.NET Launch Settings Profile' run configuration

Project:

Choose a startup project for this configuration.

Target framework:

A .NET Framework version that will be used to run this configuration.

Launch profile:

Use this selector to pick one of the profiles configured in the launchSettings.json file.

Exe path:

The path to the executable file of the selected target project is calculated automatically.

Program arguments

Arguments that will be passed to the executable when the configuration is started.

Multiple arguments should be separated with whitespaces.

For some project types (for example, Web Application), JetBrains Rider will fill this field automatically so that the target project could be started correctly.

Working directory:

The working directory is automatically set to the bin/Debug path of the selected target project.

Environmental variables:

Here you can specify custom environment variables for the target executable.

Use external console:

By default, the output of .NET and Mono applications is shown in the Run or Debug window. Use this checkbox to show the output in an external window.

This checkbox does not affect classic .NET application types (for example, .NET Console Application) — their output in always shown in an external window.

.NET runtime arguments:

Both dotnet and Mono support setting custom runtime arguments when launching an application. For example Mono supports many runtime arguments to customize how your application is run. You can select the garbage collector to be used (--gc=boehm or --gc=sgen), on macOS you can select the runtime architecture to be used (--arch=32 or --arch=64), and more.

Use mono runtime

If you are working on Windows, you can check how your application works with the mono runtime. JetBrains Rider will use the mono executable specified on the Build, Execution, Deployment | Toolset and Build page of JetBrains Rider settings CtrlAlt0S.

To debug with mono runtime, you need:

  • Mono 4.2+

  • Portable PDB in your projects — <debugtype>portable</debugtype> in the .csproj file, or alternatively, generate mdb with pdb2mdb.

The following four options are available when a IIS Express launch profile is chosen in the Launch profile: selector.

Generate applicationhost.config

To launch IIS Express with your ASP.NET Core application, JetBrains Rider uses a configuration file .idea/config/applicationhost.config, which is created using a template that ships with IIS Express. When possible, customizations you make to this file are also preserved. You might want to disable this option for heavy customizations.

Show IIS Express output

This option enables output from the IIS Express process. By default, it is disabled (as the output is quite verbose), but when enabled we can see additional details when running the application:

JetBrains Rider: IIS Express output

Send debug request

When this option is enabled, JetBrains Rider will send an initial request (with a DEBUG HTTP request method) to the target ASP.NET Core application. This ensures the application is started and the debugger is attached, even when the browser is not started.

Additional IIS Express arguments

This field lets you pass additional arguments to the IIS Express host (for example, to enable request tracing).