Bagikan melalui

Utama() dan Argumen baris perintah

Metode Main ini adalah titik masuk aplikasi C#. Ketika aplikasi dimulai, Main metode ini adalah metode pertama yang dipanggil.

Hanya ada satu titik masuk dalam program C#. Jika Anda memiliki lebih dari satu kelas yang memiliki metode Main, Anda harus mengompilasikan program Anda dengan opsi pengompilasi StartupObject untuk menentukan metode Main mana yang akan digunakan sebagai titik masuk. Untuk informasi selengkapnya, lihat StartupObject (Opsi Pengompilasi C#).
Di bawah ini adalah contoh di mana baris pertama yang dijalankan akan menampilkan jumlah argumen baris perintah:

class TestClass
{
    static void Main(string[] args)
    {
        Console.WriteLine(args.Length);
    }
}

Anda juga dapat menggunakan Pernyataan tingkat atas dalam satu file sebagai titik masuk untuk aplikasi Anda. Sama seperti metode , Main pernyataan tingkat atas juga dapat mengembalikan nilai dan mengakses argumen baris perintah. Untuk informasi selengkapnya, lihat Pernyataan tingkat atas.
Contoh berikut menggunakan perulangan foreach untuk menampilkan argumen baris perintah menggunakan variabel args, dan di akhir program mengembalikan kode keberhasilan (0):

using System.Text;

StringBuilder builder = new();
builder.AppendLine("The following arguments are passed:");

foreach (var arg in args)
{
    builder.AppendLine($"Argument={arg}");
}

Console.WriteLine(builder.ToString());

return 0;

Gambaran Umum

  • Metode Main ini adalah titik masuk dari program yang dapat dieksekusi; ini adalah tempat kontrol program dimulai dan berakhir.
  • Main harus dideklarasikan di dalam kelas atau struktur. Penutup class dapat berupa static.
  • Main harus merupakan static.
  • Maindapat memiliki pengubah akses (kecuali file).
  • Main dapat memiliki jenis pengembalian void, int, Task, atau Task<int>.
  • Jika dan hanya jika Main mengembalikan Task atau Task<int>, deklarasi Main dapat menyertakan peubah async. Ini secara khusus mengecualikan metode async void Main.
  • Metode Main ini dapat dideklarasikan dengan atau tanpa parameter string[] yang berisi argumen baris perintah. Saat menggunakan Visual Studio untuk membuat aplikasi Windows, Anda dapat menambahkan parameter secara manual atau menggunakan metode GetCommandLineArgs() untuk mendapatkan argumen baris perintah. Parameter dibaca sebagai argumen baris perintah yang diindeks nol. Tidak seperti C dan C++, nama program tidak diperlakukan sebagai argumen baris perintah pertama dalam larik args, tetapi ini adalah elemen pertama dari metode GetCommandLineArgs().

Daftar berikut ini memperlihatkan deklarasi yang paling umum Main :

static void Main() { }
static int Main() { }
static void Main(string[] args) { }
static int Main(string[] args) { }
static async Task Main() { }
static async Task<int> Main() { }
static async Task Main(string[] args) { }
static async Task<int> Main(string[] args) { }

Contoh sebelumnya tidak menentukan pengubah akses, sehingga secara implisit private secara default. Itu khas, tetapi dimungkinkan untuk menentukan pengubah akses eksplisit apa pun.

Petunjuk / Saran

Penambahan async dan Task, jenis pengembalian Task<int> menyederhanakan kode program ketika aplikasi konsol perlu dijalankan dan operasi asinkron await pada Main.

Nilai pengembalian Main()

Anda dapat mengembalikan int dari metode Main dengan mendefinisikan metode dengan salah satu cara berikut:

Main deklarasi Kode metode Main
static int Main() Tidak ada penggunaan args atau await
static int Main(string[] args) Menggunakan args, tidak menggunakan await
static async Task<int> Main() Tidak ada penggunaan args, menggunakan await
static async Task<int> Main(string[] args) Menggunakan args danawait

Jika nilai yang dikembalikan dari Main tidak digunakan, mengembalikan void atau Task memungkinkan kode yang sedikit lebih sederhana.

Main deklarasi Kode metode Main
static void Main() Tidak ada penggunaan args atau await
static void Main(string[] args) Menggunakan args, tidak menggunakan await
static async Task Main() Tidak ada penggunaan args, menggunakan await
static async Task Main(string[] args) Menggunakan args danawait

Namun, mengembalikan int atau Task<int> memungkinkan program untuk mengomunikasikan informasi status ke program atau skrip lain yang memanggil file yang dapat dieksekusi.

Contoh berikut menunjukkan bagaimana kode keluar untuk proses dapat diakses.

Contoh ini menggunakan alat baris perintah .NET Core. Jika Anda tidak terbiasa dengan alat baris perintah .NET Core, Anda dapat mempelajarinya di artikel memulai ini.

Buat aplikasi baru dengan menjalankan dotnet new console. Ubah metode Main di Program.cs sebagai berikut:

class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

Ingatlah untuk menyimpan program ini sebagai MainReturnValTest.cs.

Ketika program dijalankan dalam Windows, nilai apa pun yang dikembalikan dari fungsi Main disimpan dalam variabel lingkungan. Variabel lingkungan ini dapat diambil menggunakan ERRORLEVEL dari file batch, atau $LastExitCode dari PowerShell.

Anda dapat membangun aplikasi menggunakan perintah CLIdotnet build dotnet.

Selanjutnya, buat skrip PowerShell untuk menjalankan aplikasi dan menampilkan hasilnya. Tempelkan kode berikut ke dalam file teks dan simpan seperti test.ps1 di folder yang berisi proyek. Jalankan skrip PowerShell dengan mengetik test.ps1 di perintah PowerShell.

Karena kode mengembalikan nol, file batch akan melaporkan keberhasilan. Namun, jika Anda mengubah MainReturnValTest.cs untuk mengembalikan nilai bukan nol lalu mengompilasikan ulang program, eksekusi skrip PowerShell berikutnya akan melaporkan kegagalan.

dotnet run
if ($LastExitCode -eq 0) {
    Write-Host "Execution succeeded"
} else
{
    Write-Host "Execution Failed"
}
Write-Host "Return value = " $LastExitCode

Execution succeeded
Return value = 0

Nilai Pengembalian Main Asinkron

Ketika Anda mendeklarasikan nilai pengembalian async untuk Main, pengompilasi menghasilkan kode boilerplate untuk memanggil metode asinkron di Main. Jika Anda tidak menentukan kata kunci async, Anda perlu menulis kode itu sendiri, seperti yang ditunjukkan dalam contoh berikut. Kode dalam contoh memastikan bahwa program Anda berjalan hingga operasi asinkron selesai:

class AsyncMainReturnValTest
{
    public static int Main()
    {
        return AsyncConsoleWork().GetAwaiter().GetResult();
    }

    private static async Task<int> AsyncConsoleWork()
    {
        return 0;
    }
}

Kode templat ini dapat digantikan dengan:

class Program
{
    static async Task<int> Main(string[] args)
    {
        return await AsyncConsoleWork();
    }

    private static async Task<int> AsyncConsoleWork()
    {
        return 0;
    }
}

Dalam kedua contoh, bagian utama program berada dalam isi metode AsyncConsoleWork().

Keuntungan mendeklarasikan Main sebagai async adalah bahwa pengompilasi selalu menghasilkan kode yang benar.

Ketika titik entri aplikasi mengembalikan Task atau Task<int>, pengompilasi menghasilkan titik masuk baru yang memanggil metode titik masuk yang dideklarasikan dalam kode aplikasi. Dengan asumsi bahwa titik masuk ini disebut $GeneratedMain, pengompilasi menghasilkan kode berikut untuk titik masuk ini:

  • static Task Main() menghasilkan keluaran setara oleh pengompilasi dengan private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
  • static Task Main(string[]) menghasilkan keluaran setara oleh pengompilasi dengan private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
  • static Task<int> Main() menghasilkan keluaran setara oleh pengompilasi dengan private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
  • static Task<int> Main(string[]) menghasilkan keluaran setara oleh pengompilasi dengan private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Catatan

Jika contoh yang menggunakan peubah async pada metode Main, pengompilasi akan menghasilkan kode yang sama.

Argumen di baris perintah

Anda dapat mengirimkan argumen ke metode Main dengan mendefinisikan metode dengan salah satu cara berikut:

Main deklarasi Kode metode Main
static void Main(string[] args) Tidak ada nilai pengembalian, tidak ada penggunaan await
static int Main(string[] args) Nilai pengembalian, tidak ada penggunaan await
static async Task Main(string[] args) Tidak ada nilai balik, menggunakan await
static async Task<int> Main(string[] args) Nilai balik, menggunakan await

Jika argumen tidak digunakan, Anda dapat menghilangkan args dari deklarasi metode untuk kode yang sedikit lebih sederhana:

Main deklarasi Kode metode Main
static void Main() Tidak ada nilai pengembalian, tidak ada penggunaan await
static int Main() Nilai pengembalian, tidak ada penggunaan await
static async Task Main() Tidak ada nilai balik, menggunakan await
static async Task<int> Main() Nilai balik, menggunakan await

Catatan

Anda juga dapat menggunakan Environment.CommandLine atau Environment.GetCommandLineArgs untuk mengakses argumen baris perintah dari titik mana pun di konsol atau aplikasi Formulir Windows. Untuk mengaktifkan argumen baris perintah dalam deklarasi Main metode pada aplikasi Formulir Windows, Anda harus mengubah deklarasi Main secara manual. Kode yang dihasilkan oleh perancang Formulir Windows membuat Main tanpa parameter input.

Parameter metode Main adalah larik String yang mewakili argumen baris perintah. Biasanya Anda menentukan apakah argumen ada dengan menguji properti Length, misalnya:

if (args.Length == 0)
{
    System.Console.WriteLine("Please enter a numeric argument.");
    return 1;
}

Petunjuk / Saran

Larik args tidak boleh null. Jadi, aman untuk mengakses properti Length tanpa pemeriksaan null.

Anda juga dapat mengonversi argumen string menjadi jenis numerik dengan menggunakan kelas Convert atau metode Parse. Misalnya, pernyataan berikut mengonversi string menjadi angka long dengan menggunakan metode Parse:

long num = Int64.Parse(args[0]);

Dimungkinkan juga untuk menggunakan tipe C# long, yang beralias Int64.

long num = long.Parse(args[0]);

Anda juga dapat menggunakan kelas Convert metode ToInt64 untuk melakukan hal yang sama:

long num = Convert.ToInt64(s);

Untuk informasi lebih lanjut, lihat Parse dan Convert.

Petunjuk / Saran

Mengurai argumen baris perintah bisa kompleks. Pertimbangkan untuk menggunakan pustaka System.CommandLine (saat ini dalam versi beta) untuk menyederhanakan proses.

Contoh berikut menunjukkan cara menggunakan argumen baris perintah dalam aplikasi konsol. Aplikasi mengambil satu argumen saat dijalankan, mengonversi argumen menjadi bilangan bulat, dan menghitung faktorial dari angka tersebut. Jika tidak ada argumen yang disediakan, aplikasi mengeluarkan pesan yang menjelaskan penggunaan program yang benar.

Untuk mengompilasikan dan menjalankan aplikasi dari perintah, ikuti langkah-langkah berikut:

  1. Tempelkan kode berikut ke editor teks apa pun, lalu simpan file sebagai file teks dengan nama Factorial.cs.

    public class Functions
{
    public static long Factorial(int n)
    {
        // Test for invalid input.
        if ((n < 0) || (n > 20))
        {
            return -1;
        }

        // Calculate the factorial iteratively rather than recursively.
        long tempResult = 1;
        for (int i = 1; i <= n; i++)
        {
            tempResult *= i;
        }
        return tempResult;
    }
}

class MainClass
{
    static int Main(string[] args)
    {
        if (args.Length == 0)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        int num;
        bool test = int.TryParse(args[0], out num);
        if (!test)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        long result = Functions.Factorial(num);

        if (result == -1)
            Console.WriteLine("Input must be >= 0 and <= 20.");
        else
            Console.WriteLine($"The Factorial of {num} is {result}.");

        return 0;
    }
}

    Di awal metode Main, program menguji jika argumen input tidak disediakan membandingkan panjang argumen args dengan 0 dan menampilkan bantuan jika tidak ada argumen yang ditemukan.
    Jika argumen disediakan (args.Length lebih besar dari 0) program mencoba mengonversi argumen input menjadi angka. Ini akan melemparkan pengecualian jika argumen bukan angka.
    Setelah faktorial dihitung (disimpan dalam variabel result dengan tipe long), hasil verbose dicetak tergantung pada variabel result.

  2. Dari layar Mulai atau menu Mulai, buka jendela Perintah Pengembang Visual Studio, lalu navigasikan ke folder yang berisi file yang Anda buat.

  3. Jalankan perintah berikut untuk mengompilasikan kode.

    dotnet build

    Jika aplikasi Anda tidak memiliki kesalahan kompilasi, file yang dapat dieksekusi yang bernama Factorial.exe dibuat.

  4. Masukkan perintah berikut untuk menghitung faktorial 3:

    dotnet run -- 3

  5. Jika 3 dimasukkan pada baris perintah sebagai argumen program, output berbunyi: The factorial of 3 is 6.

Catatan

Saat menjalankan aplikasi di Visual Studio, Anda dapat menentukan argumen baris perintah di Halaman Debug, Project Designer.

Spesifikasi bahasa C#

Untuk informasi selengkapnya, lihat Spesifikasi Bahasa C#. Spesifikasi bahasa adalah sumber definitif untuk sintaks dan penggunaan C#.

Lihat juga