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

Main yöntemi, bir C# uygulamasının giriş noktasıdır. Uygulama başlatıldığında, Main yöntemi çağrılan ilk yöntemdir.

C# programında yalnızca bir giriş noktası olabilir. Yöntemi olan Main birden fazla sınıfınız varsa, giriş noktası olarak hangi Main yöntemin kullanılacağını belirtmek için programınızı StartupObject derleyici seçeneğiyle derlemeniz gerekir. Daha fazla bilgi için bkz . StartupObject (C# Derleyici Seçenekleri).

class TestClass
{
    static void Main(string[] args)
    {
        // Display the number of command line arguments.
        Console.WriteLine(args.Length);
    }
}

Uygulamanızın giriş noktası olarak bir dosyada Üst düzey deyimleri de kullanabilirsiniz. Yönteminde Main olduğu gibi, üst düzey deyimler de değer 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.

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;

Genel bakış

• Main yöntemi yürütülebilir bir programın giriş noktasıdır; program denetiminin başladığı ve bittiği yerdir.
• Main bir sınıf veya yapı içinde bildirilmelidir. Kapsayan class olabilir static.
• Main olmalıdır static.
• Main herhangi bir erişim değiştiricisi olabilir (dışında file).
• Main, , intveya TaskTask<int> dönüş türüne sahip voidolabilir.
• Yalnızca veya döndürürse Task<int>Task ve ise Main bildirimi Main değiştiriciyi async içerebilir. Bu özellikle bir async void Main yöntemi dışlar.
• yöntemi, Main komut satırı bağımsız değişkenleri içeren bir string[] parametreyle veya parametresiz olarak bildirilebilir. Windows uygulamaları oluşturmak için Visual Studio kullanırken, parametresini el ile ekleyebilir veya komut satırı bağımsız değişkenlerini almak için yöntemini kullanabilirsiniz GetCommandLineArgs() . Parametreler sıfır dizinli komut satırı bağımsız değişkenleri olarak okunur. 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. Bu tipik bir durum olsa da herhangi bir açık erişim değiştirici belirtmek mümkündür.

Main() dönüş değerleri

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

değerinin Main dönüş değeri kullanılmazsa, döndürme void veya Task biraz daha basit koda izin verir.

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 bu araçlar 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:

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

Bir program Windows'ta yürütürken, işlevden Main döndürülen tüm değerler bir ortam değişkeninde depolanır. Bu ortam değişkeni bir toplu iş dosyasından veya $LastExitCode PowerShell'den kullanılarak ERRORLEVEL alınabilir.

Dotnet CLI dotnet 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 yazarak test.ps1 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 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 hata 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

Zaman Uyumsuz Ana dönüş değerleri

için Mainbir async dönüş değeri bildirdiğinizde, derleyici içinde zaman uyumsuz yöntemleri Mainçağırmak için ortak kodu oluşturur. Anahtar sözcüğü belirtmezseniz async , aşağıdaki örnekte gösterildiği gibi bu kodu kendiniz yazmanız gerekir. Örnekteki kod, zaman uyumsuz işlem tamamlanana kadar programınızın çalışmasını sağlar:

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

    private static async Task<int> AsyncConsoleWork()
    {
        // Main body here
        return 0;
    }
}

Bu ortak kod şu şekilde değiştirilebilir:

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

    private static async Task<int> AsyncConsoleWork()
    {
        // main body here 
        return 0;
    }
}

Bildirimin Main async bir avantajı, derleyicinin her zaman doğru kodu oluşturmasıdır.

Uygulama giriş noktası veya Task Task<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() eşdeğerini yayan derleyiciyle sonuç private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
• static Task Main(string[]) eşdeğerini yayan derleyiciyle sonuç private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
• static Task<int> Main() eşdeğerini yayan derleyiciyle sonuç private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
• static Task<int> Main(string[]) eşdeğerini yayan derleyiciyle sonuç private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Komut Satırı Bağımsız Değişkenleri

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

Bağımsız değişkenler kullanılmazsa, biraz daha basit bir kod için yöntem bildiriminden atlayabilirsiniz args :

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

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

Ayrıca, sınıfını veya Parse yöntemini kullanarak Convert 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]);

Diğer adları Int64olan C# türünü longkullanmak da mümkündür:

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

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

long num = Convert.ToInt64(s);

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

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:

1. 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)
       {
           // 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.
   

2. 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.

3. Uygulamayı derlemek için aşağıdaki komutu girin.

   dotnet build

   Uygulamanızda derleme hatası yoksa, Factorial.exe adlı bir yürütülebilir dosya oluşturulur.

4. 3'ün faktöriyelini hesaplamak için aşağıdaki komutu girin:

   dotnet run -- 3

5. komutu şu çıkışı üretir: The factorial of 3 is 6.

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.

• System.Environment
• Komut satırı bağımsız değişkenlerini görüntüleme