Ana() ve komut satırı bağımsız değişkenleri

Bir C# uygulaması başlattığınızda, çalışma zamanı Main yöntemini çağırır. Main yöntemi, bir C# uygulamasının giriş noktasıdır.

C# programının yalnızca bir giriş noktası olabilir. Bir Main yöntemi olan birden fazla sınıfınız varsa, giriş noktası olarak hangi yöntemin hizmetleneceğini belirtmek için programınızı derlerken Main derleyici seçeneğini kullanmanız gerekir. Daha fazla bilgi için bkz . StartupObject (C# Derleyici Seçenekleri). Aşağıdaki örnek, ilk eylemi olarak komut satırı bağımsız değişkenlerinin sayısını görüntüler:

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

Uygulamanızın giriş noktası olarak bir dosyada üst düzey deyimleri de kullanabilirsiniz. Yöntemi gibi Main üst düzey deyimler değerler döndürebilir ve komut satırı bağımsız değişkenlerine erişebilir. Daha fazla bilgi için bkz . Üst düzey deyimler. Aşağıdaki örnek, foreach döngüsünü kullanarak, args değişkeni ile komut satırı bağımsız değişkenlerini görüntüler ve programın sonunda bir başarı kodu (0) döndürür.

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;

C# 14'te başlayan programlar, tek bir dosyanın programı içerdiği dosya tabanlı uygulamalar olabilir. dosya tabanlı uygulamaları komut dotnet <file.cs> kullanarak veya (yalnızca Unix kabukları için) ilk satır olarak #!/usr/bin/env dotnet run yönergesini kullanarak çalıştırırsınız.

Genel bakış

Main yöntemi yürütülebilir bir programın giriş noktasıdır. Program denetiminin başladığı ve bittiği yerdir.
Bir sınıf veya yapı içinde bildirmeniz Main gerekir. Kapsayan class olabilir static.
Main olmalıdır static.
Main herhangi bir erişim değiştiriciye sahip olabilir.
Main, void, int, Task veya Task<int> döndürebilir.
Eğer ve yalnızca Main, bir Task veya Task<int> döndürürse, Main bildirimi async değiştiricisini içerebilir. Bu kural özellikle bir async void Main yöntemi dışlar.
Main yöntemini, komut satırı argümanlarını içeren bir string[] parametre ile veya parametresiz olarak bildirebilirsiniz. Windows uygulamaları oluşturmak için Visual Studio kullanırken, parametreyi el ile ekleyebilir ya da komut satırı bağımsız değişkenlerini almak için GetCommandLineArgs() yöntemini de kullanabilirsiniz. Parametreler sıfır dizinli komut satırı bağımsız değişkenleridir. C ve C++'ın aksine, programın adı dizideki args ilk komut satırı bağımsız değişkeni olarak değerlendirilmez, ancak yöntemin GetCommandLineArgs() ilk öğesidir.

Aşağıdaki listede en yaygın Main bildirimler gösterilmektedir:

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) { }

Yukarıdaki örnekler bir erişim değiştirici belirtmediğinden varsayılan olarak örtük olarak private gösterilir. Herhangi bir açık erişim değiştirici belirtebilirsiniz.

İpucu

async ve Task veya Task<int> dönüş türlerini kullanarak, konsol uygulamalarında gereken await zaman uyumsuz işlemler başlatıldığında program kodunu sadeleştirirsinizMain.

Main() dönüş değerleri

yöntemini aşağıdaki yollardan biriyle tanımlayarak yönteminden int bir Main döndürebilirsiniz:

`Main` bildirim	`Main` yöntem kodu
`static int Main()`	`args` veya `await` kullanımına yer yok
`static int Main(string[] args)`	Kullanır `args` ama kullanmaz `await`
`static async Task<int> Main()`	Kullanır `await` ama kullanmaz `args`
`static async Task<int> Main(string[] args)`	Kullanır `args` ve `await`

Main'nin dönüş değeri kullanılmıyorsa, void veya Task geri döndürüldüğünde kodu biraz daha basitleştirir.

`Main` bildirim	`Main` yöntem kodu
`static void Main()`	`args` veya `await` kullanımına yer yok
`static void Main(string[] args)`	Kullanır `args` ama kullanmaz `await`
`static async Task Main()`	Kullanır `await` ama kullanmaz `args`
`static async Task Main(string[] args)`	Kullanır `args` ve `await`

Ancak, geri döndürmek int veya Task<int> programın yürütülebilir dosyayı çağıran diğer programlara veya betiklere durum bilgilerini iletmesini sağlar.

Aşağıdaki örnekte, işlemin çıkış koduna nasıl erişilebileceği gösterilmektedir.

Bu örnekte .NET Core komut satırı araçları kullanılmıştır. .NET Core komut satırı araçlarını bilmiyorsanız, bu başlangıç makalesinde bunlar hakkında bilgi edinebilirsiniz.

komutunu çalıştırarak dotnet new consoleyeni bir uygulama oluşturun. Main Program.cs yöntemini aşağıdaki gibi değiştirin:

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

Bu programı MainReturnValTest.csolarak kaydetmeyi unutmayın.

Windows'da bir program yürüttüğünizde, sistem işlevden Main döndürülen tüm değerleri bir ortam değişkeninde depolar. Bu ortam değişkenini bir toplu iş dosyasından ERRORLEVEL veya PowerShell'den $LastExitCode kullanarak alabilirsiniz.

dotnet CLIdotnet build komutunu kullanarak uygulamayı oluşturabilirsiniz.

Ardından, uygulamayı çalıştırmak ve sonucu görüntülemek için bir PowerShell betiği oluşturun. Aşağıdaki kodu bir metin dosyasına yapıştırın ve projeyi içeren klasörde olduğu gibi test.ps1 kaydedin. PowerShell istemine gidip test.ps1 yazarak PowerShell betiğini çalıştırın.

Kod sıfır döndürdüğünden, toplu iş dosyası başarıyı bildirir. Ancak, MainReturnValTest.cs'yi sıfır olmayan bir değer döndürecek şekilde değiştirir ve ardından programı yeniden derlerseniz, PowerShell betiğinin sonraki yürütülmesi başarısızlık bildirir.

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

Asenkron Ana dönüş değerleri

Bir async dönüş değeri Main için bildirdiğinizde, derleyici, Main içinde zaman uyumsuz yöntemlerin çağrılmasını sağlamak için temel kodu oluşturur.

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

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

Her iki örnekte de programın ana gövdesi yöntemin gövdesindedir AsyncConsoleWork() .

Derleyicinin her zaman doğru kodu oluşturmasının bir avantajı, bildirimin Main olarak async yapılmasıdır.

Uygulama giriş noktası veya TaskTask<int>döndürdüğünde derleyici, uygulama kodunda bildirilen giriş noktası yöntemini çağıran yeni bir giriş noktası oluşturur. Bu giriş noktasının olarak adlandırıldığını $GeneratedMainvarsayarsak, derleyici bu giriş noktaları için aşağıdaki kodu oluşturur:

static Task Main() , derleyicinin private static void $GeneratedMain() => Main().GetAwaiter().GetResult(); eşdeğerini yaymasına neden olur.
static Task Main(string[]), derleyicinin private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult(); eşdeğerini yaymasına neden olur.
static Task<int> Main() derleyicinin private static int $GeneratedMain() => Main().GetAwaiter().GetResult(); eşdeğerini üretmesine neden olur.
static Task<int> Main(string[]), derleyicinin eşdeğerini yaymasına neden olur private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();.

Not

Örnekler async değiştiricisini Main yöntemi üzerinde kullanıyorsa, derleyici aynı kodu oluşturur.

Komut satırı argümanları

Yöntemini aşağıdaki yollardan biriyle tanımlayarak yöntemine bağımsız değişkenler Main gönderebilirsiniz:

`Main` bildirim	`Main` yöntem kodu
`static void Main(string[] args)`	Dönüş değeri mevcut değil veya `await`
`static int Main(string[] args)`	Bir değer döndürür ancak kullanmaz `await`
`static async Task Main(string[] args)`	Kullanır `await` ancak değer döndürmez
`static async Task<int> Main(string[] args)`	Bir değer döndür ve `await` kullan

Bağımsız değişkenleri kullanmıyorsanız, biraz daha basit bir kod için yöntem bildiriminden atlayabilirsiniz args :

`Main` bildirim	`Main` yöntem kodu
`static void Main()`	Dönüş değeri mevcut değil veya `await`
`static int Main()`	Bir değer döndürür ancak kullanmaz `await`
`static async Task Main()`	Kullanır `await` ancak değer döndürmez
`static async Task<int> Main()`	Bir değer döndürür ve kullanır `await`

Not

Ya da Environment.CommandLine Environment.GetCommandLineArgs kullanarak konsol veya Windows Forms uygulamasının herhangi bir noktasından komut satırı bağımsız değişkenlerine erişebilirsiniz. Bir Windows Forms uygulamasında yöntem bildiriminde Main komut satırı bağımsız değişkenlerini etkinleştirmek için bildirimini Mainel ile değiştirmeniz gerekir. Windows Forms tasarımcısı tarafından oluşturulan kod, giriş parametresi olmadan oluşturulur Main .

yönteminin Main parametresi, komut satırı bağımsız değişkenlerini temsil eden bir String dizidir. Genellikle, Length özelliğini test ederek, bağımsız değişkenlerin mevcut olup olmadığını belirlersiniz, örneğin:

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

İpucu

Dizi args null olamaz. Bu nedenle, null denetimi olmadan özelliğine Length erişmek güvenlidir.

Ayrıca, Convert sınıfını veya Parse yöntemini kullanarak dize bağımsız değişkenlerini sayısal türlere dönüştürebilirsiniz. Örneğin, aşağıdaki deyim yöntemini kullanarak öğesini string bir long sayıya Parse dönüştürür:

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

C# türü long, Int64 olarak da adlandırılır ve kullanılması mümkündür.

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

Aynı işlemi yapmak için sınıf yöntemini Convert de kullanabilirsinizToInt64:

long num = Convert.ToInt64(s);

Daha fazla bilgi için bkz. Parse ve Convert.

İpucu

Komut satırı bağımsız değişkenlerini ayrıştırma karmaşık olabilir. İşlemi basitleştirmek için System.CommandLine kitaplığını (şu anda beta sürümündedir) kullanmayı göz önünde bulundurun.

Aşağıdaki örnekte, konsol uygulamasında komut satırı bağımsız değişkenlerinin nasıl kullanılacağı gösterilmektedir. Uygulama çalışma zamanında bir bağımsız değişken alır, bağımsız değişkeni tamsayıya dönüştürür ve sayının faktöriyelini hesaplar. Bağımsız değişken sağlanmazsa, uygulama programın doğru kullanımını açıklayan bir ileti görüntüler.

Uygulamayı bir komut isteminden derlemek ve çalıştırmak için şu adımları izleyin:

Aşağıdaki kodu herhangi bir metin düzenleyicisine yapıştırın ve dosyayı Factorial.cs adlı bir metin dosyası olarak kaydedin.

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;
    }
}

Yöntemin başında, program Main bağımsız değişkeninin uzunluğunu args ile karşılaştırarak giriş bağımsız değişkenlerinin sağlanmadığını test eder ve herhangi bir bağımsız değişken bulunmadığında 0 yardımı görüntüler.
Bağımsız değişkenler sağlanırsa (args.Length 0'dan büyükse), program giriş bağımsız değişkenlerini sayılara dönüştürmeyi dener. Bu örnek, bağımsız değişken bir sayı değilse bir hata fırlatır.
Faktöriyel hesaplandıktan sonra (result türünde long değişkenine depolanır), ayrıntılı sonuç result değişkenine bağlı olarak yazdırılır.

Başlangıç ekranından veya Başlat menüsünden bir Visual Studio Geliştirici Komut İstemi penceresi açın ve oluşturduğunuz dosyayı içeren klasöre gidin.
Uygulamayı derlemek için aşağıdaki komutu girin:

dotnet build

Uygulamanızda derleme hatası yoksa, derleme işlemi Factorial.dlladlı bir ikili dosya oluşturur.
3'ün faktöriyelini hesaplamak için aşağıdaki komutu girin:

dotnet run -- 3
Komut satırına programın bağımsız değişkeni olarak 3 girerseniz çıkış şu şekilde olur: The factorial of 3 is 6.

Not

Visual Studio'da bir uygulama çalıştırırken Hata Ayıklama Sayfası, Proje Tasarımcısı'nda komut satırı bağımsız değişkenlerini belirtin.

C# dili belirtimi

Daha fazla bilgi edinmek için, bkz. C# Dil Belirtimi. Dil belirtimi, C# sözdizimi ve kullanımı için kesin bir kaynaktır.

Ayrıca bkz.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-12-17

Aracılığıyla paylaş

Ana() ve komut satırı bağımsız değişkenleri

Genel bakış

Main() dönüş değerleri

Asenkron Ana dönüş değerleri

Komut satırı argümanları

C# dili belirtimi

Ayrıca bkz.

Geri Bildirim

Ek kaynaklar