dotnet run

Artikel ini berlaku untuk: ✔️ .NET 6 SDK dan versi yang lebih baru

Nama

dotnet run - Menjalankan kode sumber tanpa perintah kompilasi atau peluncuran eksplisit.

Sinopsis

dotnet run [<applicationArguments>]
  [-a|--arch <ARCHITECTURE>] [--artifacts-path <ARTIFACTS_DIR>]
  [-c|--configuration <CONFIGURATION>] [--disable-build-servers]
  [-e|--environment <KEY=VALUE>] [--file <FILE_PATH>]
  [-f|--framework <FRAMEWORK>] [--force] [--interactive]
  [-lp|--launch-profile <NAME>] [--no-build] [--no-cache]
  [--no-dependencies] [--no-launch-profile] [--no-restore] [--os <OS>]
  [-p|--property:<PROPERTYNAME>=<VALUE>]
  [--project <PATH>] [-r|--runtime <RUNTIME_IDENTIFIER>]
  [--sc|--self-contained] [--tl:[auto|on|off]] [-v|--verbosity <LEVEL>]
  [[--] [application arguments]]

dotnet run -h|--help

Deskripsi

Perintah ini dotnet run menyediakan opsi yang nyaman untuk menjalankan aplikasi Anda dari kode sumber dengan satu perintah. Ini berguna untuk pengembangan iteratif cepat dari baris perintah. Perintah bergantung pada dotnet build perintah untuk membangun kode. Persyaratan apa pun untuk build juga berlaku dotnet run .

File output ditulis ke lokasi default, yaitu bin/<configuration>/<target>. Misalnya jika Anda memiliki netcoreapp2.1 aplikasi dan Anda menjalankan dotnet run, output ditempatkan di bin/Debug/netcoreapp2.1. File ditimpa sesuai kebutuhan. File sementara ditempatkan di obj direktori.

Jika proyek menentukan beberapa kerangka kerja, menjalankan dotnet run menghasilkan kesalahan kecuali -f|--framework <FRAMEWORK> opsi digunakan untuk menentukan kerangka kerja.

Perintah dotnet run digunakan dalam konteks proyek, bukan rakitan yang dibangun. Jika Anda mencoba menjalankan DLL aplikasi yang bergantung pada kerangka kerja, Anda harus menggunakan dotnet tanpa perintah. Misalnya, untuk menjalankan myapp.dll, gunakan:

dotnet myapp.dll

Untuk informasi selengkapnya tentang driver dotnet, lihat ringkasan CLI .NET.

Untuk menjalankan aplikasi, dotnet run perintah menyelesaikan dependensi aplikasi yang berada di luar runtime bersama dari cache NuGet. Karena menggunakan dependensi cache, tidak disarankan untuk digunakan dotnet run untuk menjalankan aplikasi dalam produksi. Sebagai gantinya, buat penyebaran menggunakan dotnet publish perintah dan sebarkan output yang diterbitkan.

Pemulihan implisit

Anda tidak harus menjalankan dotnet restore karena dijalankan secara implisit oleh semua perintah yang memerlukan terjadinya pemulihan, seperti dotnet new, dotnet build, dotnet run, dotnet test, dotnet publish, dan dotnet pack. Untuk menonaktifkan pemulihan implisit, gunakan opsi --no-restore.

Perintah dotnet restore masih berguna dalam skenario tertentu di mana pemulihan secara eksplisit masuk akal, seperti build integrasi berkelanjutan di Azure DevOps Services atau dalam sistem build yang perlu mengontrol secara eksplisit ketika pemulihan terjadi.

Untuk informasi tentang cara mengelola umpan NuGet, lihat dotnet restore dokumentasi.

Perintah ini mendukung opsi dotnet restore ketika diteruskan dalam bentuk panjang (misalnya, --source). Opsi pendek, seperti -s, tidak didukung.

Pengunduhan manifes beban kerja

Saat Anda menjalankan perintah ini, pengunduhan latar belakang asinkron manifes iklan untuk beban kerja akan dimulai. Jika unduhan masih berjalan saat perintah ini selesai, unduhan akan dihentikan. Untuk informasi selengkapnya, lihat Manifes iklan.

Mulai profil

Luncurkan profil mengonfigurasi cara dotnet run memulai aplikasi selama pengembangan. Untuk proyek gaya SDK, masukkan pengaturan ke dalam Properties/launchSettings.json. Visual Basic proyek yang digunakan My Project/launchSettings.json sebagai gantinya.

Aplikasi berbasis file dapat menggunakan [ApplicationName].run.json file di samping file sumber. Untuk urutan dan contoh pencarian file, lihat Meluncurkan profil untuk aplikasi berbasis file.

File pengaturan peluncuran berisi objek tingkat profiles atas. Setiap properti dalam profiles menentukan profil bernama:

{
  "profiles": {
    "Local": {
      "commandName": "Project",
      "commandLineArgs": "--input sample.txt",
      "dotnetRunMessages": true,
      "environmentVariables": {
        "APP_MODE": "local"
      }
    }
  }
}

Pengurai pengaturan peluncuran SDK .NET menerima komentar JSON dan koma berikutnya.

Pilih profil

Gunakan --launch-profile <NAME> untuk memilih profil bernama. Kecocokan nama tidak peka huruf besar/kecil. Nama profil yang berbeda hanya menurut kasus bersifat ambigu dan menghasilkan kesalahan.

Jika Anda tidak menentukan nama, dotnet run pilih profil pertama dalam urutan file yang commandName didukungnya. Gunakan --no-launch-profile untuk melewati file pengaturan peluncuran.

Saat dotnet run menerapkan profil, profil diatur DOTNET_LAUNCH_PROFILE ke nama profil yang dipilih dalam proses yang diluncurkan. Sumber variabel lingkungan yang lebih baru dapat mengambil alih nilai.

Jenis profil yang didukung

SDK .NET mendukung nilai-nilai ini commandName untuk dotnet run. Nilai peka huruf besar/kecil.

`commandName`	Behavior
`Project`	Membangun proyek dan memulai perintah yang dihasilkan oleh proyek.
`Executable`	Memulai perintah yang ditentukan oleh `executablePath`. Kecuali Anda menentukan `--no-build`, `dotnet run` masih membangun proyek terlebih dahulu.

Properti umum

dotnet run mengenali properti ini untuk kedua jenis profil yang didukung:

dotnet run %NAME% memperluas referensi variabel lingkungan dalam nilai string yang didukung. Dalam .NET 11 dan versi yang lebih baru, ia juga memperluas referensi properti MSBuild dalam nilai yang digunakannya untuk meluncurkan proses, menggunakan penggantian token yang sama dengan Visual Studio. Ini tidak memperluas referensi gaya $NAME shell.

Property	Behavior
`commandLineArgs`	Menentukan argumen untuk proses yang diluncurkan. Argumen aplikasi eksplisit pada baris perintah lebih diutamakan. `Project` Untuk profil, argumen yang disediakan oleh project juga diutamakan.
`environmentVariables`	Menentukan variabel lingkungan untuk proses yang diluncurkan. Nilai profil mengambil alih variabel lingkungan yang diwariskan dan dihasilkan SDK, dan `-e\\|--environment` nilai mengambil alih nilai profil.
`dotnetRunMessages`	Ketika `true`, mencetak `Building...` sebelum `dotnet run` membangun proyek. Default adalah `false`. Properti ini tidak mengontrol pesan yang mengidentifikasi file pengaturan peluncuran.

Gunakan environmentVariables untuk menerapkan pengaturan konfigurasi runtime waktu pengembangan yang memiliki formulir variabel lingkungan. Misalnya, profil dapat mengatur pengaturan GC seperti DOTNET_gcServer. Untuk pengaturan yang tersedia, nama variabel lingkungan, dan aturan prioritas, lihat .NET pengaturan konfigurasi runtime dan Opsi konfigurasi runtime untuk pengumpulan sampah.

Tidak setiap pengaturan runtime memiliki formulir variabel lingkungan. Untuk mengonfigurasi aplikasi secara independen dari profil peluncurannya, gunakan properti atau RuntimeHostConfigurationOption item MSBuild dalam proyek, atau gunakan runtimeconfig.template.json file. Beberapa pengaturan juga dapat diubah dalam kode dengan AppContext.SetSwitch. Mekanisme ini menghasilkan atau memodifikasi konfigurasi runtime aplikasi; mereka bukan properti tambahan launchSettings.json .

`Project` Properti

dotnet run mengenali properti tambahan ini ketika commandName adalah Project:

Property	Behavior
`applicationUrl`	`ASPNETCORE_URLS` Set dalam proses yang diluncurkan. Nilai `ASPNETCORE_URLS` dalam atau dari `-e\\|--environment` lebih diutamakan`environmentVariables`.
`launchBrowser`	Memberi tahu alat peluncuran apakah akan membuka browser. `dotnet run` mempertahankan properti ini di profil yang diurai tetapi tidak membuka browser.
`launchUrl`	Memberi tahu alat peluncuran URL mana yang akan dibuka. `dotnet run` mempertahankan properti ini di profil yang diurai tetapi tidak membuka browser atau menggunakan URL.

Perilaku ini applicationUrl mendukung ASP.NET Core, tetapi meluncurkan profil dan properti umum lainnya berlaku untuk proyek .NET gaya SDK yang dapat dijalankan.

`Executable` Properti

dotnet run mengenali properti tambahan ini ketika commandName adalah Executable:

Property	Behavior
`executablePath`	Required. Menentukan proses yang akan dimulai. SDK memperluas referensi variabel yang didukung, tetapi tidak menyelesaikan nilai relatif terhadap file pengaturan peluncuran. Gunakan jalur absolut atau perintah yang dapat ditemukan sistem operasi.
`workingDirectory`	Optional. Menentukan direktori kerja untuk proses yang diluncurkan. SDK memperluas referensi variabel yang didukung dan menyelesaikan jalur relatif terhadap direktori yang berisi file pengaturan peluncuran. Jika Anda menghilangkan properti, direktori kerja default ke direktori yang berisi proyek atau aplikasi berbasis file.

ekstensi Visual Studio dan debugger

launchSettings.json adalah format input bersama, tetapi setiap konsumen memutuskan nilai mana yang akan didukung dan cara menafsirkannya. Visual Studio, debugger, dan alat lain dapat mengenali lebih banyak commandName nilai dan properti daripada dotnet run.

Tabel berikut membandingkan dotnet run kontrak dengan perilaku umum .NET sistem proyek dalam Visual Studio:

Pengaturan atau perilaku	`dotnet run`	Visual Studio
Jenis profil yang didukung	Mendukung `Project` dan `Executable`.	`Project`Mendukung , `Executable`, dan kosong `commandName`. Ekstensi sistem proyek yang terinstal dapat menambahkan jenis profil lainnya.
Ekspansi variabel	`%NAME%` Memperluas referensi variabel lingkungan. Dalam .NET 11 dan versi yang lebih baru, juga memperluas referensi properti MSBuild dalam nilai yang digunakannya untuk meluncurkan proses.	Memperluas variabel lingkungan dan properti MSBuild di `executablePath`, , `commandLineArgsworkingDirectory`, `launchUrl`, nilai variabel lingkungan, dan pengaturan ekstensi bernilai string.
`commandLineArgs` untuk `Project`	Menggunakan nilai profil hanya ketika proyek tidak menyediakan argumen eksekusi dan Anda tidak meneruskan argumen aplikasi pada baris perintah.	Menambahkan nilai profil ke argumen eksekusi dari proyek.
`workingDirectory` untuk `Project`	Mengabaikan properti.	Mendukung properti . Jalur relatif relatif terhadap direktori proyek.
`workingDirectory` untuk `Executable`	Jalur relatif relatif terhadap direktori yang berisi file pengaturan peluncuran. Jika dihilangkan, jalur default ke direktori aplikasi berbasis proyek atau file.	Jalur relatif relatif terhadap direktori proyek. Jika dihilangkan, jalur default ke direktori output saat direktori tersebut ada, atau ke direktori proyek sebaliknya.
Relatif `executablePath`	Meneruskan nilai ke sistem operasi tanpa mengubahnya.	Menyelesaikan nilai dengan komponen jalur dari direktori kerja profil. Untuk nama bare executable, Visual Studio memeriksa direktorinya sendiri saat ini lalu `PATH`.
`launchBrowser` dan `launchUrl`	Mempertahankan nilai di profil yang diurai tetapi tidak membuka browser.	Membuat nilai tersedia untuk penyedia peluncuran. Misalnya, alat ASP.NET Core dapat membuka browser.
`applicationUrl`	Mengatur `ASPNETCORE_URLS`.	Membuat nilai tersedia untuk penyedia peluncuran yang diinstal, seperti alat ASP.NET Core.
`dotnetRunMessages`	`Building...` Mengontrol pesan.	Tidak menggunakan properti untuk mengontrol output Visual Studio.
Properti debugger	Mengabaikan properti khusus debugger.	Menggunakan properti seperti `nativeDebugging`, , `sqlDebuggingjsWebView2Debugging`, `remoteDebugEnabled`, dan `hotReloadEnabled` saat proyek dan debugger mendukung fitur tersebut.

Dalam .NET 11 dan versi yang lebih baru, kedua konsumen memperluas "$(ProjectDir)". Dalam versi sebelumnya, tidak ada nilai tunggal yang workingDirectory mengidentifikasi direktori proyek untuk kedua konsumen. Visual Studio memperluas "$(ProjectDir)", sambil dotnet run memperlakukannya sebagai teks harfiah dan menyelesaikan jalur relatif dari direktori yang berisi file pengaturan peluncuran. Oleh karena itu, gunakan ".." untuk dotnet run dengan konvensional Properties/launchSettings.json atau My Project/launchSettings.json file. Visual Studio menyelesaikan nilai yang sama dengan induk direktori proyek.

Formulir Windows dan aplikasi WPF tidak menambahkan jenis profil laindotnet run. Project Gunakan profil dengan pengaturan umum seperti commandLineArgs dan environmentVariables. Dalam Visual Studio, jenis proyek desktop ini juga dapat menggunakan properti debugger yang berlaku, seperti nativeDebugging untuk penelusuran kesalahan terkelola campuran dan asli atau jsWebView2Debugging untuk WebView2. Properti browser dan URL hanya berpengaruh saat penyedia peluncuran atau aplikasi mengonsumsinya.

Jenis proyek lain dan beban kerja Visual Studio dapat menginstal penyedia peluncuran yang menambahkan jenis profil atau menginterpretasikan properti tambahan. Ekstensi tersebut tidak menambahkan dukungan ke dotnet run: CLI melewati jenis profil yang tidak didukung selama pemilihan default dan melaporkan kesalahan saat Anda memilihnya secara eksplisit.

Untuk pengaturan debugger Visual Studio yang didukung dan antarmuka pengguna project, lihat pengaturan Project untuk konfigurasi debug C# .NET.

Arguments

<applicationArguments>

Argumen diteruskan ke aplikasi yang sedang dijalankan.

Argumen apa pun yang tidak dikenali diteruskan dotnet run ke aplikasi. Untuk memisahkan argumen dari dotnet run argumen untuk aplikasi, gunakan -- opsi .

Meneruskan argumen ke aplikasi

dotnet run meneruskan token apa pun yang tidak dikenali oleh aplikasi. Token yang diteruskan menyimpan urutan aslinya, tetapi dotnet run terlebih dahulu menghapus opsi yang dipahaminya. Saat opsi yang dikenali muncul antara nama opsi yang tidak dikenali dan nilainya, menghapus opsi yang dikenali dapat mengubah arti token sisa.

Misalnya, perintah berikut menginterogasi opsi --project yang dikenali antara token yang dimaksudkan untuk diterima aplikasi:

dotnet run --app-flag --app-name --project ConsoleApp.csproj A.txt

Setelah dotnet run mengonsumsi --project ConsoleApp.csproj, aplikasi menerima --app-flag --app-name A.txt. Aplikasi kemudian memperlakukan A.txt sebagai nilai --app-name, yang tidak cocok dengan baris perintah asli.

Untuk menghindari ambiguitas ini, tempatkan argumen aplikasi setelah literal --:

dotnet run --project ConsoleApp.csproj -- --app-flag --app-name A.txt

Pemisah -- menandai setiap token berikut sebagai argumen aplikasi, jadi dotnet run tidak menyusun ulang atau menginterpretasikannya kembali. Pemisah juga membuktikan skrip masa depan terhadap opsi baru dotnet run yang nantinya cocok dengan token yang sebelumnya diteruskan ke aplikasi.

Note

Perilaku yang sama berlaku untuk dotnet build dan untuk dotnet test di Microsoft. Mode Testing.Platform (MTP), yang meneruskan token yang tidak dikenal ke MSBuild atau ke aplikasi pengujian masing-masing. Untuk informasi selengkapnya tentang dotnet test, lihat Meneruskan argumen ke aplikasi pengujian.

Opsi

--

Memisahkan argumen ke dotnet run dari argumen untuk aplikasi yang dijalankan. Semua argumen setelah pemisah ini diteruskan ke eksekusi aplikasi.
-a|--arch <ARCHITECTURE>

Menentukan arsitektur target. Hal ini adalah sintaks singkat untuk mengatur Pengidentifikasi Runtime (RID), di mana nilai yang disediakan digabung dengan RID default. Misalnya, pada komputer win-x64, menentukan --arch x86 akan mengatur RID ke win-x86. Jika Anda menggunakan opsi ini, jangan gunakan opsi -r|--runtime. Tersedia sejak .NET 6 Pratinjau 7.
--artifacts-path <ARTIFACTS_DIR>

Semua file output build dari perintah yang dijalankan akan masuk ke subfolder di bawah jalur yang ditentukan, dipisahkan oleh proyek. Untuk informasi selengkapnya, lihat Tata Letak Output Artefak . Opsi ini dan nilai yang disediakan harus secara eksplisit dikaitkan dalam perintah apa pun dotnet yang bergantung pada output perintah lain dotnet , misalnya, saat menggunakan dotnet build --no-restore dan dotnet publish --no-build. Tersedia sejak .NET 8 SDK.
-c|--configuration <CONFIGURATION>

Menentukan konfigurasi build. Pengaturan default untuk sebagian besar proyek adalah Debug, tetapi Anda dapat mengambil alih pengaturan konfigurasi build di proyek Anda.
--disable-build-servers

Memaksa perintah untuk mengabaikan server build persisten apa pun. Opsi ini menyediakan cara yang konsisten untuk menonaktifkan semua penggunaan penembolokan build, yang memaksa build dari awal. Build yang tidak mengandalkan cache berguna ketika cache mungkin rusak atau salah karena beberapa alasan. Tersedia sejak .NET 7 SDK.
-e|--environment <KEY=VALUE>

Mengatur variabel lingkungan yang ditentukan dalam proses yang akan dijalankan oleh perintah . Variabel lingkungan yang ditentukan tidak diterapkan ke dotnet run proses.

Variabel lingkungan yang diteruskan melalui opsi ini lebih diutamakan daripada variabel lingkungan sekitar, direktif System.CommandLine env , dan environmentVariables dari profil peluncuran yang dipilih. Untuk informasi selengkapnya, lihat Variabel lingkungan.

(Opsi ini ditambahkan di .NET SDK 9.0.200.)
-f|--framework <FRAMEWORK>

Membangun dan menjalankan aplikasi menggunakan kerangka kerja yang ditentukan. Kerangka kerja harus ditentukan dalam file proyek.
--file <FILE_PATH>

Jalur ke aplikasi berbasis file yang akan dijalankan. Jika jalur tidak ditentukan, direktori saat ini digunakan untuk menemukan dan menjalankan file. Untuk informasi selengkapnya tentang aplikasi berbasis file, lihat Membangun aplikasi C# berbasis file.

Di Unix, jalankan aplikasi berbasis file secara langsung menggunakan nama file dengan menambahkan arahan shebang (#!) dan mengatur izin eksekusi. Untuk informasi selengkapnya, lihat Dukungan shebang Unix (#!).

Diperkenalkan dalam .NET SDK 10.0.100.
--force

Memaksa semua dependensi untuk diselesaikan bahkan jika pemulihan terakhir berhasil. Menentukan bendera ini sama dengan menghapus file project.assets.json.
--interactive

Memungkinkan perintah berhenti dan menunggu input atau tindakan pengguna. Misalnya, untuk menyelesaikan autentikasi.
-lp|--launch-profile <NAME>

Nama profil peluncuran yang akan digunakan saat meluncurkan aplikasi. Untuk informasi selengkapnya, lihat Meluncurkan profil.
--no-build

Tidak membangun proyek sebelum berjalan. Ini juga secara implisit --no-restore mengatur bendera.
--no-cache

Lewati pemeriksaan terbaru dan selalu bangun program sebelum berjalan.
--no-dependencies

Saat memulihkan proyek dengan referensi project-to-project (P2P), memulihkan proyek root dan bukan referensi.
--no-launch-profile

Tidak mencoba menggunakan launchSettings.json untuk mengonfigurasi aplikasi.
--no-restore

Tidak menjalankan pemulihan implisit saat menjalankan perintah.
--no-self-contained

Terbitkan aplikasi Anda sebagai aplikasi yang bergantung pada kerangka kerja. Runtime .NET yang kompatibel harus diinstal pada komputer target untuk menjalankan aplikasi Anda.
--os <OS>

Menentukan sistem operasi (OS) target. Hal ini adalah sintaks singkat untuk mengatur Pengidentifikasi Runtime (RID), di mana nilai yang disediakan digabung dengan RID default. Misalnya, pada komputer win-x64, menentukan --os linux akan mengatur RID ke linux-x64. Jika Anda menggunakan opsi ini, jangan gunakan opsi -r|--runtime. Tersedia sejak .NET 6.
--project <PATH>

Menentukan jalur file proyek yang akan dijalankan (nama folder atau jalur lengkap). Jika tidak ditentukan, defaultnya ke direktori saat ini.

Singkatan -p untuk --project tidak digunakan lagi mulai .NET 6 SDK. Untuk waktu yang terbatas, -p masih dapat digunakan --project meskipun peringatan penghentian. Jika argumen yang disediakan untuk opsi tidak berisi =, perintah akan menerima -p sebagai singkatan --projectdari . Jika tidak, perintah mengasumsikan bahwa -p singkatan dari --property. Penggunaan fleksibel -p untuk --project akan di-fase dalam .NET 7.
--property:<NAME>=<VALUE>

Mengatur satu atau beberapa properti MSBuild. Tentukan beberapa properti yang dibatasi oleh titik koma atau dengan mengulangi opsi:
```
--property:<NAME1>=<VALUE1>;<NAME2>=<VALUE2>
--property:<NAME1>=<VALUE1> --property:<NAME2>=<VALUE2>
```
Formulir -p pendek dapat digunakan untuk --property. Jika argumen yang disediakan untuk opsi berisi =, -p diterima sebagai singkatan dari --property. Jika tidak, perintah mengasumsikan bahwa -p singkatan dari --project.

Untuk meneruskan --property ke aplikasi daripada mengatur properti MSBuild, berikan opsi setelah pemisah -- sintaks, misalnya:
```
dotnet run -- --property name=value
```
-r|--runtime <RUNTIME_IDENTIFIER>

Menentukan runtime target untuk memulihkan paket. Untuk daftar Pengidentifikasi Runtime (RID), lihat katalog RID.
--sc|--self-contained

Terbitkan runtime .NET dengan aplikasi Anda sehingga runtime tidak perlu diinstal pada komputer target.
--tl:[auto|on|off]

Menentukan apakah Terminal Logger harus digunakan untuk output build. Defaultnya adalah auto, yang pertama memverifikasi lingkungan sebelum mengaktifkan pengelogan terminal. Pemeriksaan lingkungan memverifikasi bahwa terminal mampu menggunakan fitur output modern dan tidak menggunakan output standar yang dialihkan sebelum mengaktifkan pencatat baru. on melewati pemeriksaan lingkungan dan mengaktifkan pengelogan terminal. off melewati pemeriksaan lingkungan dan menggunakan pencatat konsol default.

Terminal Logger menunjukkan fase pemulihan diikuti oleh fase build. Selama setiap fase, proyek bangunan saat ini muncul di bagian bawah terminal. Setiap proyek yang membangun menghasilkan target MSBuild yang saat ini sedang dibangun dan jumlah waktu yang dihabiskan untuk target tersebut. Anda dapat mencari informasi ini untuk mempelajari lebih lanjut tentang build. Setelah proyek selesai dibangun, satu bagian "build completed" ditulis yang menangkap:
- Nama proyek bawaan.
- Kerangka kerja target (jika multi-target).
- Status build tersebut.
- Output utama build tersebut (yang di-hyperlink).
- Diagnostik apa pun yang dihasilkan untuk proyek tersebut.
Opsi ini tersedia mulai dari .NET 8.
-v|--verbosity <LEVEL>

Mengatur tingkat verbositas perintah. Nilai yang diizinkan adalah q[uiet], m[inimal], n[ormal], d[etailed], dan diag[nostic]. Default adalah minimal. Untuk informasi selengkapnya, lihat LoggerVerbosity .
-?|-h|--help

Mencetak deskripsi cara menggunakan perintah.

Variabel lingkungan

Sumber berikut menerapkan variabel lingkungan ke aplikasi yang diluncurkan:

Variabel lingkungan sekitar dari sistem operasi saat perintah dijalankan.
Arahan System.CommandLine env , seperti [env:key=value]. Ini berlaku untuk seluruh dotnet run proses, bukan hanya proyek yang dijalankan oleh dotnet run.
Nilai yang dihasilkan dari profil peluncuran yang dipilih. dotnet run set , DOTNET_LAUNCH_PROFILEdan applicationUrl dalam Project kumpulan ASPNETCORE_URLSprofil .
environmentVariables dari profil peluncuran yang dipilih, jika ada. Ini berlaku untuk proyek yang dijalankan oleh dotnet run.
-e|--environment nilai opsi CLI (ditambahkan dalam .NET SDK versi 9.0.200). Ini berlaku untuk proyek yang dijalankan oleh dotnet run.

Lingkungan dibangun dalam urutan yang sama dengan daftar ini, sehingga -e|--environment opsi memiliki prioritas tertinggi.

Contoh

Jalankan proyek di direktori saat ini:
```
dotnet run
```
Jalankan aplikasi berbasis file yang ditentukan di direktori saat ini:
```
dotnet run --file ConsoleApp.cs
```
Dukungan aplikasi berbasis file ditambahkan di .NET SDK 10.0.100.

Jalankan proyek yang ditentukan:

dotnet run --project ./projects/proj1/proj1.csproj

Jalankan proyek di direktori saat ini, menentukan Konfigurasi rilis:
```
dotnet run --property:Configuration=Release
```
Jalankan proyek di direktori saat ini ( --help argumen dalam contoh ini diteruskan ke aplikasi, karena opsi kosong -- digunakan):
```
dotnet run --configuration Release -- --help
```
Pulihkan dependensi dan alat untuk proyek di direktori saat ini hanya memperlihatkan output minimal lalu jalankan proyek:
```
dotnet run --verbosity m
```
Jalankan proyek di direktori saat ini menggunakan kerangka kerja yang ditentukan dan teruskan argumen ke aplikasi:
```
dotnet run -f net6.0 -- arg1 arg2
```
Dalam contoh berikut, tiga argumen diteruskan ke aplikasi. Satu argumen diteruskan menggunakan -, dan dua argumen diteruskan setelah --:
```
dotnet run -f net6.0 -arg1 -- arg2 arg3
```

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-09-08