Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

feat(run): .NET project run and debug configurations (#686)

l0ng-ai245fe3cdf40c
diff --git a/crates/ide-host/src/ops/run/commands.rs b/crates/ide-host/src/ops/run/commands.rs
index 7a916a519..c1b2acc73 100644
--- a/crates/ide-host/src/ops/run/commands.rs
+++ b/crates/ide-host/src/ops/run/commands.rs
@@ -5,6 +5,23 @@ use crate::rpc::Dispatcher;
use ide_core::{IdeError, IdeResult};
use ide_run::RunConfig;
+pub async fn run_dotnet_resolve(host: &Host, window: &str, config: RunConfig, debug: bool) -> IdeResult<RunConfig> {
+ host.require_trust(window)?;
+ if !matches!(config.kind.as_str(), "dotnet" | "dotnet-test")
+ || config.extras.target.as_ref().is_some_and(|s| !s.is_empty())
+ {
+ return Err(IdeError::invalid(".NET Project requires the local machine"));
+ }
+ let project = host.project(window)?;
+ let mut config = host.blocking(move || ide_run::dotnet::resolve(&project.root, config)).await?;
+ if debug {
+ let root = host.project(window)?.root.clone();
+ let target = ide_run::dotnet::target_path(&root, &config).await?;
+ config.extras.params.insert("targetPath".into(), target);
+ }
+ Ok(config)
+}
+
fn application_cache(project: &crate::project::Project, id: &str) -> std::path::PathBuf {
use std::hash::{Hash, Hasher};
let mut hash = std::collections::hash_map::DefaultHasher::new();
@@ -206,6 +223,9 @@ pub async fn run_tomcat_update(host: &Host, window: &str, config: RunConfig, mod
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
+ d.add("run_dotnet_resolve", |c| async move {
+ run_dotnet_resolve(&c.host, &c.window, c.arg("config")?, c.arg("debug")?).await
+ });
d.add("run_application_build", |c| async move {
run_application_build(&c.host, &c.window, c.arg("config")?, c.arg("module")?).await
});
diff --git a/crates/ide-run/src/detect.rs b/crates/ide-run/src/detect.rs
index 13a1f5d5c..82f365949 100644
--- a/crates/ide-run/src/detect.rs
+++ b/crates/ide-run/src/detect.rs
@@ -4,6 +4,7 @@
//! Detection never fails: unreadable or malformed files simply contribute nothing.
pub(crate) mod cmake;
+mod dotnet;
use crate::RunConfig;
use serde_json::Value as Json;
@@ -33,6 +34,7 @@ pub(crate) fn detect_with_profiles(
detect_go(root, &mut out);
detect_python(root, &mut out);
cmake::detect(root, profiles, &mut out);
+ dotnet::detect(root, &mut out);
detect_make(root, &mut out);
detect_just(root, &mut out);
detect_godot(root, &mut out);
diff --git a/crates/ide-run/src/detect/dotnet.rs b/crates/ide-run/src/detect/dotnet.rs
new file mode 100644
index 000000000..ce1f433e0
--- /dev/null
+++ b/crates/ide-run/src/detect/dotnet.rs
@@ -0,0 +1,121 @@
+//! Runnable .NET projects and launch profiles, without a solution model.
+
+use crate::{
+ RunConfig,
+ dotnet::{parse_project, profiles, solution_projects},
+};
+use std::{
+ collections::{BTreeMap, BTreeSet},
+ fs,
+ path::Path,
+};
+
+pub(crate) fn detect(root: &Path, out: &mut Vec<RunConfig>) {
+ let mut dirs = vec![root.to_path_buf()];
+ let mut projects = BTreeSet::new();
+ while let Some(dir) = dirs.pop() {
+ let Ok(entries) = fs::read_dir(&dir) else { continue };
+ for entry in entries.flatten() {
+ let path = entry.path();
+ let name = entry.file_name().to_string_lossy().into_owned();
+ if entry.file_type().is_ok_and(|t| t.is_dir()) {
+ if !name.starts_with('.')
+ && !matches!(
+ name.as_str(),
+ "bin" | "obj" | "node_modules" | "target" | "build" | "dist" | "vendor" | "packages"
+ )
+ {
+ dirs.push(path);
+ }
+ } else if entry.file_type().is_ok_and(|t| t.is_file()) {
+ match path.extension().and_then(|e| e.to_str()).unwrap_or_default().to_ascii_lowercase().as_str() {
+ "csproj" => {
+ projects.insert(path);
+ }
+ "sln" | "slnx" => {
+ if let Ok(src) = fs::read_to_string(&path) {
+ for project in solution_projects(
+ &src,
+ path.extension().is_some_and(|e| e.eq_ignore_ascii_case("slnx")),
+ ) {
+ projects.insert(dir.join(project));
+ }
+ }
+ }
+ _ => {}
+ }
+ }
+ }
+ }
+ let root = dunce::canonicalize(root).unwrap_or_else(|_| root.into());
+ let projects: BTreeSet<_> = projects.into_iter().filter_map(|p| dunce::canonicalize(p).ok()).collect();
+ for path in projects {
+ let Some(project) = fs::read_to_string(&path).ok().and_then(|s| parse_project(&s)) else { continue };
+ let rel = path.strip_prefix(&root).unwrap_or(&path).to_string_lossy().replace('\\', "/");
+ let name = path.file_stem().unwrap_or_default().to_string_lossy();
+ let profiles = profiles(&path);
+ let mut params = BTreeMap::from([
+ ("project".into(), rel.clone()),
+ ("framework".into(), project.frameworks.first().cloned().unwrap_or_default()),
+ ("frameworks".into(), project.frameworks.join(";")),
+ ("profiles".into(), serde_json::to_string(&profiles).unwrap_or_default()),
+ ("launchProfile".into(), String::new()),
+ ("programArgs".into(), String::new()),
+ ]);
+ if project.executable && !project.test {
+ out.push(detected(&rel, &name, "", params.clone(), false));
+ for profile in profiles.keys() {
+ params.insert("launchProfile".into(), profile.clone());
+ out.push(detected(&rel, &name, profile, params.clone(), false));
+ }
+ }
+ if project.test {
+ params.insert("launchProfile".into(), String::new());
+ out.push(detected(&rel, &name, "", params, true));
+ }
+ }
+}
+
+fn detected(project: &str, name: &str, profile: &str, params: BTreeMap<String, String>, test: bool) -> RunConfig {
+ let op = if test { "test" } else { "run" };
+ let mut config = super::config(
+ format!("dotnet:{project}:{op}:{profile}"),
+ if test {
+ format!("dotnet test ({name})")
+ } else if profile.is_empty() {
+ format!("{name} (.NET Project)")
+ } else {
+ format!("{name}: {profile}")
+ },
+ if test { "dotnet-test" } else { "dotnet" },
+ "dotnet",
+ &[],
+ );
+ config.args = command_args(&params, test);
+ config.is_test = test;
+ config.debug_adapter = (!test).then(|| "netcoredbg".into());
+ config.extras.params = params;
+ if !test {
+ config.extras.before_launch.push(crate::BeforeLaunchTask { kind: "dotnetBuild".into(), target: String::new() });
+ }
+ config
+}
+
+fn command_args(params: &BTreeMap<String, String>, test: bool) -> Vec<String> {
+ let mut args = if test {
+ vec!["test".into(), params.get("project").cloned().unwrap_or_default()]
+ } else {
+ vec!["run".into(), "--project".into(), params.get("project").cloned().unwrap_or_default()]
+ };
+ if let Some(framework) = params.get("framework").filter(|s| !s.is_empty()) {
+ args.extend(["--framework".into(), framework.clone()]);
+ }
+ if !test {
+ if let Some(profile) = params.get("launchProfile").filter(|s| !s.is_empty()) {
+ args.extend(["--launch-profile".into(), profile.clone()]);
+ } else {
+ args.push("--no-launch-profile".into());
+ }
+ }
+ args
+}
diff --git a/crates/ide-run/src/dotnet.rs b/crates/ide-run/src/dotnet.rs
new file mode 100644
index 000000000..1ba990f60
--- /dev/null
+++ b/crates/ide-run/src/dotnet.rs
@@ -0,0 +1,257 @@
+//! Lightweight .NET project discovery; MSBuild remains the authority for build outputs.
+
+use crate::RunConfig;
+use ide_core::{IdeError, IdeResult};
+use quick_xml::{Reader, XmlVersion, events::Event};
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::fs;
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Default, PartialEq)]
+pub struct Project {
+ pub executable: bool,
+ pub frameworks: Vec<String>,
+ pub test: bool,
+}
+
+#[derive(Default)]
+struct Element {
+ name: String,
+ attrs: BTreeMap<String, String>,
+ text: String,
+ conditional: bool,
+}
+
+fn elements(xml: &str) -> Option<Vec<Element>> {
+ let mut reader = Reader::from_str(xml);
+ let mut out: Vec<Element> = Vec::new();
+ let mut stack: Vec<usize> = Vec::new();
+ loop {
+ let event = reader.read_event().ok()?;
+ let empty = matches!(&event, Event::Empty(_));
+ match event {
+ Event::Start(tag) | Event::Empty(tag) => {
+ let attrs: BTreeMap<_, _> = tag
+ .attributes()
+ .map(|a| {
+ let a = a.ok()?;
+ Some((
+ a.key.as_ref().to_owned(),
+ a.normalized_value(XmlVersion::Implicit1_0).ok()?.into_owned(),
+ ))
+ })
+ .collect::<Option<_>>()?;
+ let conditional = attrs.contains_key("Condition") || stack.last().is_some_and(|i| out[*i].conditional);
+ out.push(Element {
+ name: tag.local_name().as_ref().to_owned(),
+ attrs,
+ conditional,
+ ..Default::default()
+ });
+ // Empty elements have no corresponding End event.
+ if !empty {
+ stack.push(out.len() - 1);
+ }
+ }
+ Event::End(_) => {
+ stack.pop()?;
+ }
+ Event::Text(text) => {
+ if let Some(i) = stack.last() {
+ out[*i].text.push_str(&text.xml_content(XmlVersion::Implicit1_0));
+ }
+ }
+ Event::CData(text) => {
+ if let Some(i) = stack.last() {
+ out[*i].text.push_str(text.as_ref());
+ }
+ }
+ Event::GeneralRef(reference) => {
+ let name = reference.as_ref();
+ let escaped = format!("&{name};");
+ if let Some(i) = stack.last() {
+ out[*i].text.push_str(&quick_xml::escape::unescape(&escaped).ok()?);
+ }
+ }
+ Event::Eof => return stack.is_empty().then_some(out),
+ _ => {}
+ }
+ }
+}
+
+pub fn parse_project(xml: &str) -> Option<Project> {
+ let tags = elements(xml)?;
+ if tags.first()?.name != "Project" {
+ return None;
+ }
+ let property = |name: &str| tags.iter().rev().find(|t| t.name == name && !t.conditional).map(|t| t.text.trim());
+ let web = tags.iter().any(|t| {
+ t.attrs
+ .get("Sdk")
+ .or_else(|| (t.name == "Sdk").then(|| t.attrs.get("Name")).flatten())
+ .is_some_and(|s| s.split(';').any(|sdk| sdk.split('/').next() == Some("Microsoft.NET.Sdk.Web")))
+ });
+ let executable = match property("OutputType") {
+ Some(output) => output.eq_ignore_ascii_case("exe") || output.eq_ignore_ascii_case("winexe"),
+ None => web,
+ };
+ let frameworks = property("TargetFramework")
+ .filter(|v| !v.is_empty())
+ .or_else(|| property("TargetFrameworks"))
+ .unwrap_or_default()
+ .split(';')
+ .map(str::trim)
+ .filter(|v| !v.is_empty())
+ .map(str::to_owned)
+ .collect();
+ let test = tags.iter().any(|t| {
+ t.name == "PackageReference"
+ && t.attrs
+ .get("Include")
+ .or_else(|| t.attrs.get("Update"))
+ .is_some_and(|v| v.eq_ignore_ascii_case("Microsoft.NET.Test.Sdk"))
+ });
+ Some(Project { executable, frameworks, test })
+}
+
+#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase", default)]
+pub struct Profile {
+ pub command_name: String,
+ pub command_line_args: String,
+ pub working_directory: String,
+ pub application_url: String,
+ pub environment_variables: BTreeMap<String, String>,
+}
+
+pub fn parse_profiles(json: &str) -> BTreeMap<String, Profile> {
+ let Ok(json) = serde_json::from_str::<serde_json::Value>(&ide_core::jsonc::strip(json)) else {
+ return BTreeMap::new();
+ };
+ json["profiles"]
+ .as_object()
+ .into_iter()
+ .flatten()
+ .filter_map(|(name, value)| {
+ let profile: Profile = serde_json::from_value(value.clone()).ok()?;
+ (profile.command_name == "Project").then(|| (name.clone(), profile))
+ })
+ .collect()
+}
+
+pub fn solution_projects(src: &str, xml: bool) -> Vec<PathBuf> {
+ let paths: Vec<String> = if xml {
+ elements(src)
+ .unwrap_or_default()
+ .into_iter()
+ .filter(|e| e.name == "Project")
+ .filter_map(|mut e| e.attrs.remove("Path"))
+ .collect()
+ } else {
+ src.lines()
+ .filter_map(|line| {
+ let line = line.trim();
+ if !line.starts_with("Project(") {
+ return None;
+ }
+ Some(line.split_once('=')?.1.split('"').nth(3)?.to_owned())
+ })
+ .collect()
+ };
+ paths
+ .into_iter()
+ .filter(|p| p.to_ascii_lowercase().ends_with(".csproj"))
+ .map(|p| PathBuf::from(p.replace('\\', "/")))
+ .collect()
+}
+
+pub(crate) fn profiles(project: &Path) -> BTreeMap<String, Profile> {
+ project
+ .parent()
+ .and_then(|p| fs::read_to_string(p.join("Properties/launchSettings.json")).ok())
+ .map(|s| parse_profiles(&s))
+ .unwrap_or_default()
+}
+
+/// Resolves the selected profile afresh so changing project/profile never reuses stale values.
+pub fn resolve(root: &Path, mut config: RunConfig) -> IdeResult<RunConfig> {
+ let params = &config.extras.params;
+ let project = params
+ .get("project")
+ .filter(|s| !s.trim().is_empty())
+ .ok_or_else(|| IdeError::invalid("Select a .NET project"))?;
+ let project = dunce::canonicalize(root.join(project))?;
+ let dir = project.parent().ok_or_else(|| IdeError::invalid("Invalid .NET project path"))?;
+ let profile_name = params.get("launchProfile").cloned().unwrap_or_default();
+ let profile = if profile_name.is_empty() {
+ Profile::default()
+ } else {
+ profiles(&project).remove(&profile_name).ok_or_else(|| {
+ IdeError::invalid(format!(".NET launch profile '{profile_name}' is missing or is not a Project profile"))
+ })?
+ };
+ let mut env = profile.environment_variables;
+ if !profile.application_url.is_empty() {
+ env.insert("ASPNETCORE_URLS".into(), profile.application_url);
+ }
+ if !profile_name.is_empty() {
+ env.insert("DOTNET_LAUNCH_PROFILE".into(), profile_name);
+ }
+ env.extend(config.env);
+ config.env = env;
+ config.cwd = Some(
+ config
+ .cwd
+ .map(|p| root.join(&*p))
+ .unwrap_or_else(|| {
+ if profile.working_directory.is_empty() { dir.into() } else { dir.join(&profile.working_directory) }
+ })
+ .into(),
+ );
+ config.extras.params.insert("project".into(), project.to_string_lossy().into_owned());
+ config.extras.params.insert("profileArgs".into(), profile.command_line_args);
+ Ok(config)
+}
+
+/// Queries the evaluated output path, including AssemblyName, OutputPath and imported properties.
+pub async fn target_path(root: &Path, config: &RunConfig) -> IdeResult<String> {
+ let params = &config.extras.params;
+ let project = params.get("project").ok_or_else(|| IdeError::invalid("Select a .NET project"))?;
+ let mut args = vec![
+ "msbuild".to_owned(),
+ root.join(project).to_string_lossy().into_owned(),
+ "-nologo".into(),
+ "-getProperty:TargetPath".into(),
+ "-p:Configuration=Debug".into(),
+ ];
+ if let Some(framework) = params.get("framework").filter(|s| !s.is_empty()) {
+ args.push(format!("-p:TargetFramework={framework}"));
+ }
+ let mut command = std::process::Command::new(&config.command);
+ ide_core::process::host_env(&mut command);
+ command.args(args).current_dir(root);
+ if !config.extras.include_system_env {
+ command.env_clear();
+ } else {
+ command.envs(ide_core::process::shell_env());
+ }
+ command.envs(crate::resolved_env(root, config)?);
+ let mut command = tokio::process::Command::from(command);
+ command.kill_on_drop(true);
+ let output = tokio::time::timeout(std::time::Duration::from_secs(30), command.output())
+ .await
+ .map_err(|_| IdeError::unavailable(".NET output resolution timed out"))??;
+ if !output.status.success() {
+ return Err(IdeError::invalid(format!(
+ ".NET output resolution failed: {}{}",
+ String::from_utf8_lossy(&output.stdout),
+ String::from_utf8_lossy(&output.stderr)
+ )));
+ }
+ let target = String::from_utf8_lossy(&output.stdout).trim().to_owned();
+ if target.is_empty() || !Path::new(&target).is_file() {
+ return Err(IdeError::invalid(".NET build output is missing; run dotnet build before debugging"));
+ }
+ Ok(target)
+}
diff --git a/crates/ide-run/src/lib.rs b/crates/ide-run/src/lib.rs
index 95bf00bd3..f35036b1b 100644
--- a/crates/ide-run/src/lib.rs
+++ b/crates/ide-run/src/lib.rs
@@ -2,6 +2,7 @@
mod config;
mod detect;
+pub mod dotnet;
pub mod envfile;
pub mod go;
pub mod gradle_jvm;
diff --git a/crates/ide-run/tests/dotnet.rs b/crates/ide-run/tests/dotnet.rs
new file mode 100644
index 000000000..61befdd55
--- /dev/null
+++ b/crates/ide-run/tests/dotnet.rs
@@ -0,0 +1,138 @@
+use ide_run::{
+ detect,
+ dotnet::{parse_profiles, parse_project, resolve, solution_projects},
+};
+use std::fs;
+use std::path::PathBuf;
+
+const CONSOLE: &str = r#"<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><OutputType>Exe</OutputType><TargetFrameworks>net10.0; net9.0</TargetFrameworks></PropertyGroup></Project>"#;
+const PROFILES: &str = r#"{
+ // Only Project profiles can be run with dotnet.
+ "profiles": {
+ "http": {"commandName":"Project", "applicationUrl":"http://localhost:5165", "commandLineArgs":"--message \"hello world\"", "workingDirectory":"work", "environmentVariables":{"DEMO":"profile"}},
+ "https": {"commandName":"Project", "environmentVariables":{"DEMO":"https"}},
+ "IIS Express": {"commandName":"IISExpress"},
+ "external": {"commandName":"Executable"},
+ "broken": {"commandName":"Project", "environmentVariables":7}
+ }
+}"#;
+
+fn write(root: &std::path::Path, file: &str, src: &str) {
+ let path = root.join(file);
+ fs::create_dir_all(path.parent().unwrap()).unwrap();
+ fs::write(path, src).unwrap();
+}
+
+#[test]
+fn project_properties_and_sdk_defaults() {
+ let p = parse_project(CONSOLE).unwrap();
+ assert!(p.executable && !p.test);
+ assert_eq!(p.frameworks, ["net10.0", "net9.0"]);
+ for (sdk, output, executable) in [
+ ("Microsoft.NET.Sdk", "", false),
+ ("Microsoft.NET.Sdk", "<OutputType>WinExe</OutputType>", true),
+ ("Microsoft.NET.Sdk.Web", "", true),
+ ("Microsoft.NET.Sdk.Web", "<OutputType>Library</OutputType>", false),
+ ] {
+ let xml = format!(
+ r#"<Project Sdk="{sdk}"><PropertyGroup>{output}<TargetFramework>net10.0</TargetFramework></PropertyGroup></Project>"#
+ );
+ let p = parse_project(&xml).unwrap();
+ assert_eq!(p.executable, executable, "{xml}");
+ assert_eq!(p.frameworks, ["net10.0"]);
+ }
+ let p = parse_project(r#"<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"><Sdk Name="Microsoft.NET.Sdk.Web"/><PropertyGroup><TargetFramework>net10.0</TargetFramework></PropertyGroup><PropertyGroup Condition="'$(Configuration)'=='Release'"><OutputType>Library</OutputType></PropertyGroup><ItemGroup><PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0" /></ItemGroup></Project>"#).unwrap();
+ assert!(p.executable && p.test);
+ assert!(parse_project("<Project><PropertyGroup>").is_none());
+ assert!(parse_project("garbage").is_none());
+ assert!(
+ parse_project(
+ r#"<Project><ItemGroup><PackageReference Update="microsoft.net.test.sdk" /></ItemGroup></Project>"#
+ )
+ .unwrap()
+ .test
+ );
+ assert!(
+ !parse_project(r#"<Project><!-- <PackageReference Include="Microsoft.NET.Test.Sdk"/> --></Project>"#)
+ .unwrap()
+ .test
+ );
+}
+
+#[test]
+fn profiles_filter_and_preserve_launch_properties() {
+ let p = parse_profiles(PROFILES);
+ assert_eq!(p.keys().map(String::as_str).collect::<Vec<_>>(), ["http", "https"]);
+ assert_eq!(p["http"].application_url, "http://localhost:5165");
+ assert_eq!(p["http"].environment_variables["DEMO"], "profile");
+ assert_eq!(p["http"].command_line_args, "--message \"hello world\"");
+ assert_eq!(p["http"].working_directory, "work");
+ assert!(parse_profiles("invalid").is_empty());
+}
+
+#[test]
+fn solution_paths_support_windows_separators_folders_and_entities() {
+ let sln = "Project(\"{guid}\") = \"App\", \"src\\App\\App.csproj\", \"{guid}\"\nEndProject\nProject(\"{folder}\") = \"Folder\", \"Folder\", \"{guid}\"\nProject(\"{guid}\") = \"External\", \"..\\other\\Other.csproj\", \"{guid}\"";
+ assert_eq!(
+ solution_projects(sln, false),
+ [PathBuf::from("src/App/App.csproj"), PathBuf::from("../other/Other.csproj")]
+ );
+ let slnx = r#"<Solution><Folder Name="/src/"><Project Path="src\A&amp;B\App.csproj" /></Folder><Project Path="other.vbproj" /></Solution>"#;
+ assert_eq!(solution_projects(slnx, true), [PathBuf::from("src/A&B/App.csproj")]);
+ assert!(solution_projects("<Solution><Project", true).is_empty());
+}
+
+#[test]
+fn detection_deduplicates_projects_and_generates_commands() {
+ let temp = tempfile::tempdir().unwrap();
+ let root = temp.path();
+ write(root, "src/App/App.csproj", CONSOLE);
+ write(root, "src/App/Properties/launchSettings.json", PROFILES);
+ write(
+ root,
+ "demo.slnx",
+ r#"<Solution><Project Path="src/App/App.csproj"/><Project Path="../external/Missing.csproj"/></Solution>"#,
+ );
+ write(
+ root,
+ "src/Test/Test.csproj",
+ r#"<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><TargetFramework>net10.0</TargetFramework></PropertyGroup><ItemGroup><PackageReference Include="Microsoft.NET.Test.Sdk"/></ItemGroup></Project>"#,
+ );
+ write(root, "bin/Ignored.csproj", CONSOLE);
+ write(root, "obj/Ignored.csproj", CONSOLE);
+ write(root, "node_modules/Ignored.csproj", CONSOLE);
+ write(root, "Lib.csproj", "<Project Sdk=\"Microsoft.NET.Sdk\" />");
+ let configs = detect(root);
+ assert_eq!(configs.len(), 4);
+ let app = configs.iter().find(|c| c.extras.params.get("launchProfile").is_some_and(|p| p == "http")).unwrap();
+ assert_eq!(
+ app.args,
+ ["run", "--project", "src/App/App.csproj", "--framework", "net10.0", "--launch-profile", "http"]
+ );
+ assert_eq!(app.debug_adapter.as_deref(), Some("netcoredbg"));
+ assert_eq!(app.extras.before_launch[0].kind, "dotnetBuild");
+ let test = configs.iter().find(|c| c.is_test).unwrap();
+ assert_eq!(test.kind, "dotnet-test");
+ assert_eq!(test.args, ["test", "src/Test/Test.csproj", "--framework", "net10.0"]);
+ assert!(test.debug_adapter.is_none());
+ let mut edited = app.clone();
+ edited.env.insert("DEMO".into(), "override".into());
+ let resolved = resolve(root, edited.clone()).unwrap();
+ assert_eq!(resolved.env["DEMO"], "override");
+ assert_eq!(resolved.env["ASPNETCORE_URLS"], "http://localhost:5165");
+ assert!(resolved.cwd.unwrap().ends_with("src/App/work"));
+ edited.extras.params.insert("launchProfile".into(), "https".into());
+ let resolved = resolve(root, edited).unwrap();
+ assert!(!resolved.env.contains_key("ASPNETCORE_URLS"));
+ assert!(resolved.cwd.unwrap().ends_with("src/App"));
+}
+
+#[test]
+fn solution_references_can_reach_projects_outside_the_open_directory() {
+ let temp = tempfile::tempdir().unwrap();
+ write(temp.path(), "external/App.csproj", CONSOLE);
+ write(temp.path(), "open/demo.sln", "Project(\"{guid}\") = \"App\", \"..\\external\\App.csproj\", \"{guid}\"");
+ let configs = detect(&temp.path().join("open"));
+ assert_eq!(configs.len(), 1);
+ assert!(configs[0].args[2].ends_with("external/App.csproj"));
+}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 2d37e23ea..ba2822494 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -305,6 +305,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
term::term_default_shell,
term::term_available_shells,
run::run_configs,
+ run::run_dotnet_resolve,
run::run_save_configs,
run::run_templates,
run::run_save_templates,
diff --git a/src-tauri/src/commands/run.rs b/src-tauri/src/commands/run.rs
index 998cb5b9d..3bdbcecd2 100644
--- a/src-tauri/src/commands/run.rs
+++ b/src-tauri/src/commands/run.rs
@@ -8,6 +8,17 @@ use ide_run::{OutputChunk, RunConfig, RunInfo};
use tauri::ipc::Channel;
use tauri::{State, Window};
+#[tauri::command]
+#[specta::specta]
+pub async fn run_dotnet_resolve(
+ window: Window,
+ state: State<'_, AppState>,
+ config: RunConfig,
+ debug: bool,
+) -> IdeResult<RunConfig> {
+ ide_host::ops::run::run_dotnet_resolve(&state.host, window.label(), config, debug).await
+}
+
#[tauri::command]
#[specta::specta]
pub async fn run_application_build(
diff --git a/src/bindings.ts b/src/bindings.ts
index e2a005bb4..f4603e362 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -565,6 +565,7 @@ export const commands = {
termAvailableShells: () => __TAURI_INVOKE<string[]>("term_available_shells"),
/** Detected configs followed by user-defined ones (user ids win on conflict). */
runConfigs: () => typedError<RunConfig_Serialize[], IdeError>(__TAURI_INVOKE("run_configs")),
+ runDotnetResolve: (config: RunConfig_Deserialize, debug: boolean) => typedError<RunConfig_Serialize, IdeError>(__TAURI_INVOKE("run_dotnet_resolve", { config, debug })),
runSaveConfigs: (configs: RunConfig_Deserialize[], removedDetectedIds: string[] | null) => typedError<null, IdeError>(__TAURI_INVOKE("run_save_configs", { configs, removedDetectedIds })),
/** Configuration templates: per-type defaults applied to new configurations. */
runTemplates: () => typedError<RunConfig_Serialize[], IdeError>(__TAURI_INVOKE("run_templates")),
diff --git a/src/features/debugger/__tests__/launch.test.ts b/src/features/debugger/__tests__/launch.test.ts
index 19fac437f..d52afa226 100644
--- a/src/features/debugger/__tests__/launch.test.ts
+++ b/src/features/debugger/__tests__/launch.test.ts
@@ -321,3 +321,23 @@ describe("Go build configuration fields", () => {
});
});
});
+
+it("netcoredbg launches the evaluated DLL with resolved profile arguments, env and cwd", () => {
+ const c = rc({
+ kind: "dotnet",
+ command: "dotnet",
+ debugAdapter: "netcoredbg",
+ cwd: "/repo/work",
+ env: { ASPNETCORE_URLS: "http://localhost:5165", DEMO: "override" },
+ params: { targetPath: "/repo/custom/Renamed.dll", programArgs: "--name 'hello world'", profileArgs: "--profile" },
+ });
+ expect(launchConfigFor(c, "/repo")).toMatchObject({
+ adapter: "netcoredbg",
+ program: "/repo/custom/Renamed.dll",
+ args: ["--name", "hello world"],
+ cwd: "/repo/work",
+ env: c.env,
+ });
+ expect(launchConfigFor({ ...c, params: { ...c.params, programArgs: "" } }, "/repo")?.args).toEqual(["--profile"]);
+ expect(launchConfigFor({ ...c, params: {} }, "/repo")).toBeNull();
+});
diff --git a/src/features/debugger/__tests__/missingAdapter.test.ts b/src/features/debugger/__tests__/missingAdapter.test.ts
index 656ba9563..feb17d383 100644
--- a/src/features/debugger/__tests__/missingAdapter.test.ts
+++ b/src/features/debugger/__tests__/missingAdapter.test.ts
@@ -21,6 +21,9 @@ describe("missing debug adapters", () => {
expect(
missingAdapter("kotlin-debug-adapter", unavailable("debug adapter `kotlin-debug-adapter` not found (x)"))?.tool,
).toBe("kotlin-debug-adapter");
+ expect(missingAdapter("netcoredbg", unavailable("debug adapter `netcoredbg` not found (x)"))?.tool).toBe(
+ "netcoredbg",
+ );
expect(missingAdapter("delve", unavailable("debug adapter `delve` not found (x)"))?.tool).toBe("delve");
});
diff --git a/src/features/debugger/actions.ts b/src/features/debugger/actions.ts
index 098395a0e..2db2c3e62 100644
--- a/src/features/debugger/actions.ts
+++ b/src/features/debugger/actions.ts
@@ -297,7 +297,9 @@ async function startConfig(arg: unknown) {
await startJavaConfig(config, root, origin ?? config);
return;
}
- const launch = launchConfigFor(config, root);
+ const dotnet = config.kind === "dotnet" && config.debugAdapter === "netcoredbg";
+ const prepared = dotnet ? await call(commands.runDotnetResolve(config, true)) : config;
+ const launch = launchConfigFor(prepared, root);
if (!launch) {
notifications().notify({
group: "run",
diff --git a/src/features/debugger/launch.ts b/src/features/debugger/launch.ts
index 8f593baad..86b039a6d 100644
--- a/src/features/debugger/launch.ts
+++ b/src/features/debugger/launch.ts
@@ -313,6 +313,15 @@ export function launchConfigFor(rc: RunConfig, root: string): LaunchConfig | nul
if (adapter === "js-debug") return jsDebugLaunch(rc, cwd);
if (adapter === "delve") return delveLaunch(rc, cwd, root);
if (adapter === "godot") return godotLaunch(rc, cwd);
+ if (adapter === "netcoredbg" && rc.kind === "dotnet") {
+ if (!rc.params?.targetPath) return null;
+ return {
+ ...base(rc, adapter, cwd),
+ program: rc.params.targetPath,
+ args: parseArgs(rc.params.programArgs?.trim() ? rc.params.programArgs : rc.params.profileArgs || ""),
+ extraJson: JSON.stringify({ justMyCode: workflowSettings().debugger.skipLibraryCode }),
+ };
+ }
// Adapters without a template (hidden in Edit Configurations): generic arguments.
return {
...base(rc, adapter, cwd),
diff --git a/src/features/debugger/missingAdapter.ts b/src/features/debugger/missingAdapter.ts
index 8106ea519..dabfb4024 100644
--- a/src/features/debugger/missingAdapter.ts
+++ b/src/features/debugger/missingAdapter.ts
@@ -7,6 +7,7 @@ import { IpcError } from "@/platform/ipc";
/** Adapters the tools installer can provide (adapter id → tool name). */
const INSTALLABLE: Record<string, { tool: string; title: string }> = {
"kotlin-debug-adapter": { tool: "kotlin-debug-adapter", title: "The Kotlin debugger is not installed" },
+ netcoredbg: { tool: "netcoredbg", title: "netcoredbg is not installed" },
debugpy: { tool: "debugpy", title: "debugpy is not installed" },
"js-debug": { tool: "js-debug", title: "The JavaScript debugger (vscode-js-debug) is not installed" },
delve: { tool: "delve", title: "Delve is not installed" },
diff --git a/src/features/run/ConfigForm.tsx b/src/features/run/ConfigForm.tsx
index 1d11ed2d4..3c5e8d30a 100644
--- a/src/features/run/ConfigForm.tsx
+++ b/src/features/run/ConfigForm.tsx
@@ -48,11 +48,12 @@ import styles from "./Run.module.css";
/**
* Debug adapters with a real launch template (`debugger/launch.ts`, `debugger/java.ts`),
- * verified against small programs. Others (netcoredbg, dart, php-debug, …) only got
+ * verified against small programs. Others (dart, php-debug, …) only got
* generic launch arguments and are left out until they have one; a configuration that
* already names one keeps it.
*/
const ADAPTERS: ReadonlyArray<{ id: string; label: string }> = [
+ { id: "netcoredbg", label: "netcoredbg (.NET)" },
{ id: "java-debug", label: "java-debug (Java)" },
{ id: "kotlin-debug-adapter", label: "kotlin-debug-adapter (Kotlin)" },
{ id: "debugpy", label: "debugpy (Python)" },
@@ -254,6 +255,9 @@ export function ConfigForm({ config, all, type, errors, template, onChange, modi
})),
},
{ label: TASK_LABELS.build, icon: "build-project", run: () => addTask("build") },
+ ...(config.kind === "dotnet"
+ ? [{ label: TASK_LABELS.dotnetBuild, icon: "build-project", run: () => addTask("dotnetBuild") }]
+ : []),
{
label: TASK_LABELS.tool,
disabled: !externalTools.length,
diff --git a/src/features/run/beforeLaunch.ts b/src/features/run/beforeLaunch.ts
index fc0e632f8..8ce13fbd7 100644
--- a/src/features/run/beforeLaunch.ts
+++ b/src/features/run/beforeLaunch.ts
@@ -2,6 +2,7 @@
* Before launch tasks (IDEA's "Before launch" list): run in order before a
* configuration starts; the first failure aborts the launch.
*/
+import { dotnetBuildConfig } from "./dotnetTypes";
import { executeAction, getAction } from "@/platform/actions";
import { getContext } from "@/platform/context";
import { tx, txTemplate } from "@/platform/i18n";
@@ -14,11 +15,12 @@ import { startRun, useRun } from "./store";
export const BUILD_ACTION = "build.buildProject";
const BUILD_STATUS = "build.lastStatus";
-export type BeforeLaunchKind = "run" | "build" | "tool" | "command" | "toolWindow";
+export type BeforeLaunchKind = "run" | "build" | "tool" | "command" | "toolWindow" | "dotnetBuild";
export const TASK_LABELS: Record<BeforeLaunchKind, string> = {
run: "Run Another Configuration",
build: "Build Project",
+ dotnetBuild: "Build .NET project",
tool: "Run External Tool",
command: "Run Shell Command",
toolWindow: "Activate Tool Window",
@@ -32,6 +34,8 @@ export function taskLabel(task: BeforeLaunchTask, configs: readonly RunConfig[]
return `Run '${configs.find((c) => c.id === target)?.name ?? target}'`;
case "build":
return "Build Project";
+ case "dotnetBuild":
+ return "Build .NET project";
case "tool":
return `External tool '${workflowSettings().externalTools.find((t) => t.id === target)?.name ?? target}'`;
case "command":
@@ -58,6 +62,8 @@ async function runToEnd(config: RunConfig, chain: readonly string[]): Promise<bo
async function runTask(task: BeforeLaunchTask, config: RunConfig, chain: readonly string[]): Promise<string | null> {
const target = task.target ?? "";
switch (task.kind) {
+ case "dotnetBuild":
+ return (await runToEnd(dotnetBuildConfig(config), chain)) ? null : "Build failed";
case "build": {
if (!getAction(BUILD_ACTION)) return "Building is not available";
if (!(await executeAction(BUILD_ACTION, { activate: false }))) return "A build is already running";
diff --git a/src/features/run/configs.ts b/src/features/run/configs.ts
index 7669141b6..5d94cb2a8 100644
--- a/src/features/run/configs.ts
+++ b/src/features/run/configs.ts
@@ -67,6 +67,9 @@ export function configIcon(config: Pick<RunConfig, "kind" | "isTest">): string {
return "file-gradle";
case "maven":
return "file-maven";
+ case "dotnet":
+ case "dotnet-test":
+ return "file-csharp";
case "go":
return "file-go";
case "node":
@@ -220,7 +223,7 @@ export function validateConfig(config: RunConfig, all: readonly RunConfig[] = []
for (const t of config.beforeLaunch ?? []) {
if (t.kind === "run" && (t.target === config.id || !all.some((c) => c.id === t.target)))
errors.beforeLaunch = "A before launch task runs a missing configuration or this one";
- else if (t.kind !== "build" && t.kind !== "run" && !(t.target ?? "").trim())
+ else if (t.kind !== "build" && t.kind !== "dotnetBuild" && t.kind !== "run" && !(t.target ?? "").trim())
errors.beforeLaunch = "A before launch task is incomplete";
}
for (const key of Object.keys(config.env)) {
diff --git a/src/features/run/dotnetTypes.test.tsx b/src/features/run/dotnetTypes.test.tsx
new file mode 100644
index 000000000..93d5f16a9
--- /dev/null
+++ b/src/features/run/dotnetTypes.test.tsx
@@ -0,0 +1,123 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { commands } from "@/platform/ipc";
+import type { RunConfig } from "@/platform/ipc";
+import { useProject } from "@/platform/project";
+import { dotnetBuildConfig, dotnetProjectType, dotnetTestType } from "./dotnetTypes";
+import { ConfigForm } from "./ConfigForm";
+import { validateConfig } from "./configs";
+import { newConfigOfType, registerBuiltinTypes, withParams } from "./types";
+
+const resolveDotnet = vi.hoisted(() => vi.fn());
+vi.mock("@/platform/ipc", async (importOriginal) => {
+ const real = await importOriginal<typeof import("@/platform/ipc")>();
+ return { ...real, commands: { ...real.commands, runDotnetResolve: resolveDotnet } };
+});
+
+const params = {
+ project: "src/My App/App.csproj",
+ framework: "net10.0",
+ frameworks: "net10.0;net9.0",
+ launchProfile: "local web",
+ programArgs: "--name 'hello world'",
+ profiles: JSON.stringify({
+ "local web": { applicationUrl: "http://localhost:5165", environmentVariables: { DEMO: "profile" } },
+ alternate: {},
+ }),
+};
+let dispose: () => void;
+beforeEach(() => {
+ dispose = registerBuiltinTypes();
+});
+afterEach(() => dispose());
+
+function config(): RunConfig {
+ return withParams({ ...newConfigOfType(dotnetProjectType, []), name: "demo" }, params, dotnetProjectType);
+}
+
+describe(".NET configurations", () => {
+ it("generates run/test commands with spaces, framework/profile and separated program arguments", () => {
+ const c = config();
+ expect(c.args).toEqual([
+ "run",
+ "--project",
+ "src/My App/App.csproj",
+ "--framework",
+ "net10.0",
+ "--launch-profile",
+ "local web",
+ "--",
+ "--name",
+ "hello world",
+ ]);
+ expect(c.debugAdapter).toBe("netcoredbg");
+ expect(c.beforeLaunch).toEqual([{ kind: "dotnetBuild", target: "" }]);
+ expect(validateConfig(c, [c])).toEqual({});
+ const t = withParams(
+ newConfigOfType(dotnetTestType, []),
+ { project: params.project, framework: "net9.0", programArgs: '--filter "Category=Unit"' },
+ dotnetTestType,
+ );
+ expect(t.isTest).toBe(true);
+ expect(t.debugAdapter).toBeNull();
+ expect(t.args).toEqual(["test", params.project, "--framework", "net9.0", "--filter", "Category=Unit"]);
+ expect(dotnetProjectType.commandLine({ project: "App.csproj" })?.args).toEqual([
+ "run",
+ "--project",
+ "App.csproj",
+ "--no-launch-profile",
+ ]);
+ });
+
+ it("builds edited project/framework from the open root instead of a profile cwd", () => {
+ useProject.setState({ project: { root: "/repo" } as never });
+ const c = withParams(
+ { ...config(), cwd: "profile/work" },
+ { ...params, project: "other/App.csproj", framework: "net9.0" },
+ );
+ const build = dotnetBuildConfig(c);
+ expect(build.args).toEqual(["build", "other/App.csproj", "--configuration", "Debug", "--framework", "net9.0"]);
+ expect(build.cwd).toBe("/repo");
+ expect(build.beforeLaunch).toEqual([]);
+ });
+
+ it("edits project, framework, profile, arguments and environment in the shared form", () => {
+ const c = config();
+ const change = vi.fn();
+ render(
+ <ConfigForm config={c} all={[c]} type={dotnetProjectType} errors={{}} modifyRequest={0} onChange={change} />,
+ );
+ expect(screen.getByText("http://localhost:5165")).toBeTruthy();
+ expect(screen.getByText("DEMO=profile")).toBeTruthy();
+ for (const [label, value] of [
+ [".NET project", "other/App.csproj"],
+ ["Target framework", "net9.0"],
+ ["Launch profile", "alternate"],
+ ["Program arguments", "--edited"],
+ ] as const) {
+ fireEvent.change(screen.getByLabelText(label), { target: { value } });
+ expect(change).toHaveBeenCalled();
+ }
+ fireEvent.change(screen.getByRole("textbox", { name: "Environment variables" }), {
+ target: { value: "DEMO=override" },
+ });
+ expect(change.mock.lastCall?.[0]).toMatchObject({ env: { DEMO: "override" } });
+ });
+ it("prepares Run from the freshly resolved profile while keeping explicit argument overrides", async () => {
+ const c = config();
+ resolveDotnet.mockResolvedValue({
+ status: "ok",
+ data: {
+ ...c,
+ cwd: "/repo/work",
+ env: { DEMO: "override" },
+ params: { ...params, project: "/repo/App.csproj", profileArgs: "--from-profile" },
+ },
+ });
+ const prepared = await dotnetProjectType.prepareLaunch!(c);
+ expect(commands.runDotnetResolve).toHaveBeenCalledWith(c, false);
+ expect(prepared).toMatchObject({ cwd: "/repo/work", env: { DEMO: "override" } });
+ expect(prepared.args).toContain("--no-launch-profile");
+ expect(prepared.args.slice(-3)).toEqual(["--", "--name", "hello world"]);
+ });
+});
diff --git a/src/features/run/dotnetTypes.ts b/src/features/run/dotnetTypes.ts
new file mode 100644
index 000000000..534ed5733
--- /dev/null
+++ b/src/features/run/dotnetTypes.ts
@@ -0,0 +1,134 @@
+import { call, commands, type RunConfig } from "@/platform/ipc";
+import { useProject } from "@/platform/project";
+import type { RunConfigTypeContribution } from "@/workbench/contributions";
+import { parseArgs } from "./configs";
+
+function profile(p: Readonly<Record<string, string>>): {
+ applicationUrl?: string;
+ environmentVariables?: Record<string, string>;
+} {
+ try {
+ return JSON.parse(p.profiles || "{}")[p.launchProfile || ""] ?? {};
+ } catch {
+ return {};
+ }
+}
+
+export function dotnetCommand(p: Readonly<Record<string, string>>, test = false) {
+ return {
+ command: p.executable || "dotnet",
+ args: [
+ ...(test ? ["test", p.project || ""] : ["run", "--project", p.project || ""]),
+ ...(p.framework ? ["--framework", p.framework] : []),
+ ...(!test ? (p.launchProfile ? ["--launch-profile", p.launchProfile] : ["--no-launch-profile"]) : []),
+ ...(p.programArgs?.trim() ? ["--", ...parseArgs(p.programArgs)] : []),
+ ],
+ };
+}
+
+/** Build the current project/framework, independently of the run's profile working directory. */
+export function dotnetBuildConfig(config: RunConfig): RunConfig {
+ const p = config.params ?? {};
+ return {
+ ...config,
+ id: `dotnet-build:${config.id}`,
+ name: `dotnet build (${p.project || ""})`,
+ kind: "shell",
+ args: ["build", p.project || "", "--configuration", "Debug", ...(p.framework ? ["--framework", p.framework] : [])],
+ cwd: useProject.getState().project?.root ?? null,
+ env: {},
+ params: {},
+ isTest: false,
+ debugAdapter: null,
+ beforeLaunch: [],
+ emulateTerminal: false,
+ stdinFile: undefined,
+ };
+}
+
+export const dotnetProjectType: RunConfigTypeContribution = {
+ id: "dotnet",
+ label: ".NET Project",
+ icon: "file-csharp",
+ description: "Run a .NET project with a launch profile",
+ debugAdapter: "netcoredbg",
+ fields: [
+ {
+ key: "project",
+ label: ".NET project",
+ mono: true,
+ required: true,
+ suggestions: (configs) => [
+ ...new Set(
+ configs.filter((c) => c.kind === "dotnet" || c.kind === "dotnet-test").map((c) => c.params?.project || ""),
+ ),
+ ],
+ },
+ {
+ key: "framework",
+ label: "Target framework",
+ mono: true,
+ suggestions: (_configs, p) => (p.frameworks || "").split(";").filter(Boolean),
+ },
+ {
+ key: "launchProfile",
+ label: "Launch profile",
+ mono: true,
+ hint: "Empty disables launch profiles",
+ suggestions: (_configs, p) => {
+ try {
+ return Object.keys(JSON.parse(p.profiles || "{}"));
+ } catch {
+ return [];
+ }
+ },
+ },
+ { key: "programArgs", label: "Program arguments", mono: true, hint: "Empty uses the launch profile's arguments" },
+ {
+ key: "applicationUrl",
+ label: "Application URL",
+ control: "output",
+ value: (p) => profile(p).applicationUrl || "",
+ },
+ {
+ key: "profileEnvironment",
+ label: "Profile environment variables",
+ control: "output",
+ value: (p) =>
+ Object.entries(profile(p).environmentVariables ?? {})
+ .map(([k, v]) => `${k}=${v}`)
+ .join("; "),
+ hint: "Environment variables below override the profile",
+ },
+ ],
+ commandLine: (p) => dotnetCommand(p),
+ async prepareLaunch(config) {
+ const resolved = await call(commands.runDotnetResolve(config, false));
+ const p = resolved.params ?? {};
+ // Materialize the profile so explicit environment/cwd edits also apply on older SDKs.
+ const args = parseArgs(p.programArgs?.trim() ? p.programArgs : p.profileArgs || "");
+ return {
+ ...resolved,
+ args: [
+ ...dotnetCommand({ ...p, launchProfile: "", programArgs: "" }).args,
+ ...(args.length ? ["--", ...args] : []),
+ ],
+ };
+ },
+};
+
+export const dotnetTestType: RunConfigTypeContribution = {
+ id: "dotnet-test",
+ label: "dotnet test",
+ icon: "file-csharp",
+ description: "Run .NET tests",
+ fields: [...dotnetProjectType.fields.slice(0, 2), { key: "programArgs", label: "Test arguments", mono: true }],
+ commandLine(p) {
+ const line = dotnetCommand({ ...p, programArgs: "" }, true);
+ return { ...line, args: [...line.args, ...parseArgs(p.programArgs || "")] };
+ },
+ async prepareLaunch(config) {
+ const resolved = await call(commands.runDotnetResolve(config, false));
+ return { ...resolved, ...dotnetTestType.commandLine(resolved.params ?? {}) };
+ },
+};
diff --git a/src/features/run/types.ts b/src/features/run/types.ts
index b0345cd25..1ad2edf87 100644
--- a/src/features/run/types.ts
+++ b/src/features/run/types.ts
@@ -22,6 +22,8 @@ import { useProject } from "@/platform/project";
import { tomcatType } from "./tomcat";
import { goBuildType, goTestType } from "./goTypes";
+import { dotnetProjectType, dotnetTestType } from "./dotnetTypes";
+
export const COMPOUND = "compound";
const on = (v: string | undefined) => v === "true";
@@ -396,6 +398,8 @@ export const BUILTIN_TYPES: readonly RunConfigTypeContribution[] = [
maven,
godot,
pytest,
+ dotnetProjectType,
+ dotnetTestType,
goBuildType,
goTestType,
applicationType,
@@ -444,6 +448,10 @@ export function withParams(config: RunConfig, params: Record<string, string>, ty
if (!line) return { ...rest, params, command: "", args: [] };
return {
...rest,
+ ...(config.kind === "dotnet" && config.beforeLaunch === undefined
+ ? { beforeLaunch: [{ kind: "dotnetBuild", target: "" }] }
+ : {}),
+ ...(config.kind === "dotnet-test" ? { isTest: true } : {}),
params: params.goKind ? { ...params, programArgv: JSON.stringify(parseArgs(params.programArgs ?? "")) } : params,
...(config.kind === "go-test" && !config.id.startsWith("template:") ? { kind: "go" } : {}),
...(params.goKind ? { isTest: params.goKind === "test" } : {}),
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index b92b21660..43edfc7fe 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -5470,5 +5470,25 @@
"Build arguments": "构建参数",
"CMake default": "CMake 默认",
"Quote arguments containing spaces. Build arguments go to cmake --build; use -- before native build tool options.": "包含空格的参数请加引号。构建参数传给 cmake --build;原生构建工具参数前请加 --。",
- "CMake profile {0}": "CMake 配置 {0}"
+ "CMake profile {0}": "CMake 配置 {0}",
+ ".NET Project": ".NET 项目",
+ ".NET project": ".NET 项目",
+ "Run a .NET project with a launch profile": "使用启动配置运行 .NET 项目",
+ "Target framework": "目标框架",
+ "Launch profile": "启动配置",
+ "Empty disables launch profiles": "留空则禁用启动配置",
+ "Empty uses the launch profile's arguments": "留空则使用启动配置中的参数",
+ "Application URL": "应用 URL",
+ "Profile environment variables": "启动配置中的环境变量",
+ "Environment variables below override the profile": "下方的环境变量会覆盖启动配置中的值",
+ "Build .NET project": "构建 .NET 项目",
+ "Run .NET tests": "运行 .NET 测试",
+ "Test arguments": "测试参数",
+ "netcoredbg is not installed": "未安装 netcoredbg",
+ ".NET Project requires the local machine": ".NET 项目需要在本机运行",
+ "Select a .NET project": "请选择 .NET 项目",
+ "Invalid .NET project path": ".NET 项目路径无效",
+ ".NET launch profile '{profile_name}' is missing or is not a Project profile": ".NET 启动配置“{profile_name}”不存在或不是 Project 类型",
+ ".NET output resolution timed out": ".NET 构建产物路径查询超时",
+ ".NET build output is missing; run dotnet build before debugging": ".NET 构建产物不存在,请在调试前运行 dotnet build"
}
diff --git a/src/platform/locales/textCatalog.test.ts b/src/platform/locales/textCatalog.test.ts
index 2079d23aa..827d795fb 100644
--- a/src/platform/locales/textCatalog.test.ts
+++ b/src/platform/locales/textCatalog.test.ts
@@ -79,6 +79,8 @@ const BUILT_AT_RUNTIME = new Set<string>([]);
/** Text that stays as written in every locale: names, code, formats, shortcuts. */
const UNTRANSLATED = new Set<string>([
+ "dotnet test",
+ "netcoredbg (.NET)",
// Product names
"Cargo",
"CMake",
@@ -486,6 +488,21 @@ function scanTypeScript(): Scan {
return { translated, literals, untranslatable, spliced };
}
+/** Read strings without letting a Rust character literal open a string match. */
+function backendLiterals(source: string): string[] {
+ const out: string[] = [];
+ for (const m of source.matchAll(/'(?:\\.|[^'\\\r\n])'|"((?:[^"\\]|\\.)*)"/g)) {
+ if (m[1] !== undefined) out.push(m[1]);
+ }
+ return out;
+}
+
+it("reads backend messages after quote character literals", () => {
+ expect(
+ backendLiterals(`let quote = '"'; let message = "Select a .NET project"; let detail = "Expected 'x'";`),
+ ).toEqual(["Select a .NET project", "Expected 'x'"]);
+});
+
/** String literals of the Rust crates and language definitions (backend messages). */
function scanBackend(literals: Set<string>) {
const files = [
@@ -494,7 +511,7 @@ function scanBackend(literals: Set<string>) {
...walk(`${ROOT}languages`, (p) => p.endsWith(".toml")),
];
for (const file of files)
- for (const m of readFileSync(file, "utf8").matchAll(/"((?:[^"\\]|\\.)*)"/g)) literals.add(shape(m[1]!));
+ for (const literal of backendLiterals(readFileSync(file, "utf8"))) literals.add(shape(literal));
}
/** Text that needs no translation: no words, a path / glob / option, or listed in `UNTRANSLATED`. */