Utama() dan Argumen baris-perintah

Artikel
06/22/2024

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#).

class TestClass
{
    static void Main(string[] args)
    {
        // Display the number of command line arguments.
        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.

using System.Text;

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

// Display the command line arguments using the args variable.
foreach (var arg in args)
{
    builder.AppendLine($"Argument={arg}");
}

Console.WriteLine(builder.ToString());

// Return a success code.
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. class Penutupnya bisa .static
Main harus merupakan static.
Maindapat memiliki pengubah akses (kecuali file).
Main dapat memiliki voidjenis , int, Task, atau Task<int> kembali.
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.

Tip

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

Nilai pengembalian Utama()

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 ada penggunaan`await`
`static async Task<int> Main()`	Tidak ada penggunaan `args`, menggunakan `await`
`static async Task<int> Main(string[] args)`	Menggunakan `args` dan`await`

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 ada penggunaan`await`
`static async Task Main()`	Tidak ada penggunaan `args`, menggunakan `await`
`static async Task Main(string[] args)`	Menggunakan `args` dan`await`

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:

// Save this program as MainReturnValTest.cs.
class MainReturnValTest
{
    static int Main()
    {
        //...
        return 0;
    }
}

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 CLI dotnet 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 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()
    {
        // Main body here
        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()
    {
        // main body here 
        return 0;
    }
}

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 pengompilasi yang memancarkan setara dengan private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task Main(string[]) menghasilkan pengompilasi yang memancarkan setara dengan private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
static Task<int> Main() menghasilkan pengompilasi yang memancarkan setara dengan private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
static Task<int> Main(string[]) menghasilkan pengompilasi yang memancarkan setara 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 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 kembali, tidak ada penggunaan `await`
`static int Main(string[] args)`	Nilai kembali, tidak ada penggunaan `await`
`static async Task Main(string[] args)`	Tidak ada nilai kembali, menggunakan `await`
`static async Task<int> Main(string[] args)`	Nilai kembali, 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 kembali, tidak ada penggunaan `await`
`static int Main()`	Nilai kembali, tidak ada penggunaan `await`
`static async Task Main()`	Tidak ada nilai kembali, menggunakan `await`
`static async Task<int> Main()`	Nilai kembali, 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 Main deklarasi metode dalam aplikasi Formulir Windows, Anda harus mengubah deklarasi secara manual .Main 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;
}

Tip

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 long jenis C#, yang alias 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.

Tip

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:

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)
    {
        // Test if input arguments were supplied.
        if (args.Length == 0)
        {
            Console.WriteLine("Please enter a numeric argument.");
            Console.WriteLine("Usage: Factorial <num>");
            return 1;
        }

        // Try to convert the input arguments to numbers. This will throw
        // an exception if the argument is not a number.
        // num = int.Parse(args[0]);
        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;
        }

        // Calculate factorial.
        long result = Functions.Factorial(num);

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

        return 0;
    }
}
// If 3 is entered on command line, the
// output reads: The factorial of 3 is 6.

Dari layar Mulai atau menu Mulai, buka jendela Perintah Pengembang Visual Studio, lalu navigasikan ke folder yang berisi file yang Anda buat.
Jalankan perintah berikut untuk mengompilasikan kode.

dotnet build

Jika aplikasi Anda tidak memiliki kesalahan kompilasi, file yang dapat dieksekusi yang bernama Factorial.exe dibuat.
Masukkan perintah berikut untuk menghitung faktorial 3:

dotnet run -- 3
Perintah ini menghasilkan output ini: 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#.

Bagikan melalui

Utama() dan Argumen baris-perintah

Gambaran Umum

Nilai pengembalian Utama()

Nilai pengembalian Asinkron

Argumen baris perintah

Spesifikasi bahasa C#

Lihat juga

Saran dan Komentar

Sumber Daya Tambahan: