Main() och kommandoradsargument

Metoden Main är startpunkten för ett C#-program. När programmet startas är metoden den Main första metoden som anropas.

Det kan bara finnas en startpunkt i ett C#-program. Om du har fler än en klass som har en Main metod måste du kompilera programmet med kompilatoralternativet StartupObject för att ange vilken metod som Main ska användas som startpunkt. Mer information finns i StartupObject (C#-kompilatoralternativ). I följande exempel visas antalet kommandoradsargument som första åtgärd:

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

Du kan också använda toppnivåinstruktioner i en fil som startpunkt för ditt program. Precis som Main metoden kan toppnivåinstruktioner också returnera värden och komma åt kommandoradsargument. Mer information finns i toppnivåuttalanden. I följande exempel används en foreach loop för att visa kommandoradsargumenten med hjälp av variabeln args , och i slutet av programmet returneras en lyckad kod (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;

Från och med C# 14 kan program vara filbaserade appar, där en enda fil innehåller programmet. Du kör filbaserade appar med kommandot dotnet run <file.cs>eller använder #!/usr/local/share/dotnet/dotnet run direktivet som den första raden (endast unix-gränssnitt).

Översikt

• Metoden Main är startpunkten för ett körbart program. Det är där programkontrollen startar och slutar.
• Main måste deklareras i en klass eller struct. Det omgivande class kan vara static.
• Main måste vara static.
• Main kan ha alla åtkomstmodifierare (förutom file).
• Main kan antingen ha en returtyp av void, int, Task eller Task<int>.
• Om och endast om Main returnerar en Task eller Task<int>kan deklarationen av Main innehålla async modifieraren. Den här regeln utesluter specifikt en async void Main metod.
• Metoden Main kan deklareras med eller utan en string[] parameter som innehåller kommandoradsargument. När du använder Visual Studio för att skapa Windows-program kan du lägga till parametern manuellt eller använda GetCommandLineArgs() metoden för att hämta kommandoradsargumenten. Parametrar läss som nollindexerade kommandoradsargument. Till skillnad från C och C++ behandlas inte namnet på programmet som det första kommandoradsargumentet i matrisen args , men det är det första elementet i GetCommandLineArgs() metoden.

I följande lista visas de vanligaste Main deklarationerna:

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

Föregående exempel anger inte någon åtkomstmodifierare, så de är implicita private som standard. Det går att ange en explicit åtkomstmodifierare.

Returvärden för Main()

Du kan returnera en int från Main metoden genom att definiera metoden på något av följande sätt:

Om returvärdet från Main inte används returnerar void eller Task tillåter lite enklare kod.

Men om du returnerar int eller Task<int> gör det möjligt för programmet att kommunicera statusinformation till andra program eller skript som anropar den körbara filen.

I följande exempel visas hur slutkoden för processen kan nås.

I det här exemplet används .NET Core-kommandoradsverktyg . Om du inte är bekant med .NET Core-kommandoradsverktyg kan du lära dig mer om dem i den här kom igång-artikeln.

Skapa ett nytt program genom att köra dotnet new console. Main Ändra metoden i Program.cs på följande sätt:

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

Kom ihåg att spara programmet som MainReturnValTest.cs.

När ett program körs i Windows lagras alla värden som returneras från Main funktionen i en miljövariabel. Den här miljövariabeln kan hämtas från ERRORLEVEL en batchfil eller $LastExitCode från PowerShell.

Du kan bygga applikationen med hjälp av dotnet CLI-kommandotdotnet build.

Skapa sedan ett PowerShell-skript för att köra programmet och visa resultatet. Klistra in följande kod i en textfil och spara den som test.ps1 i mappen som innehåller projektet. Kör PowerShell-skriptet genom att test.ps1 skriva i PowerShell-prompten.

Eftersom koden returnerar noll rapporterar batchfilen att den lyckades. Men om du ändrar MainReturnValTest.cs för att returnera ett icke-nollvärde och sedan kompilera om programmet rapporteras körningen av PowerShell-skriptet som misslyckad.

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

Returvärden för Async Main

När du deklarerar ett async returvärde för Maingenererar kompilatorn exempelkoden för att anropa asynkrona metoder i Main:

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

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

I båda exemplen finns huvudtexten i programmet i brödtexten för AsyncConsoleWork()-metoden.

En fördel med att Main deklarera som async är att kompilatorn alltid genererar rätt kod.

När programmets startpunkt returnerar en Task eller Task<int>genererar kompilatorn en ny startpunkt som anropar startpunktsmetoden som deklarerats i programkoden. Om den här startpunkten kallas $GeneratedMaingenererar kompilatorn följande kod för dessa startpunkter:

• static Task Main() resulterar i att kompilatorn avger motsvarande private static void $GeneratedMain() => Main().GetAwaiter().GetResult();
• static Task Main(string[]) resulterar i att kompilatorn avger motsvarande private static void $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();
• static Task<int> Main() resulterar i att kompilatorn avger motsvarande private static int $GeneratedMain() => Main().GetAwaiter().GetResult();
• static Task<int> Main(string[]) resulterar i att kompilatorn avger motsvarande private static int $GeneratedMain(string[] args) => Main(args).GetAwaiter().GetResult();

Kommandoradsargument

Du kan skicka argument till Main metoden genom att definiera metoden på något av följande sätt:

Om argumenten inte används, kan du utelämna args från metoddeklarationen för något enklare kod.

Parametern för Main metoden är en String matris som representerar kommandoradsargumenten. Vanligtvis avgör du om argument finns genom att testa egenskapen Length , till exempel:

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

Du kan också konvertera strängargumenten till numeriska typer med hjälp Convert av -klassen eller Parse -metoden. Följande instruktion konverterar string till exempel till ett long tal med hjälp Parse av metoden:

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

Det går också att använda C#-typen long, som alias Int64:

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

Du kan också använda Convert klassmetoden ToInt64 för att göra samma sak:

long num = Convert.ToInt64(s);

Mer information finns i Parse och Convert.

I följande exempel visas hur du använder kommandoradsargument i ett konsolprogram. Programmet tar ett argument vid körning, konverterar argumentet till ett heltal och beräknar talets faktor. Om inga argument anges utfärdar programmet ett meddelande som förklarar rätt användning av programmet.

Följ dessa steg för att kompilera och köra programmet från en kommandotolk:

1. Klistra in följande kod i valfri textredigerare och spara sedan filen som en textfil med namnet 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;
       }
   }
   

   I början av Main metoden testar programmet om indataargument inte angavs och jämför längden på args argumentet med 0 och visar hjälpen om inga argument hittas.
   Om argumenten anges (args.Length är större än 0) försöker programmet konvertera indataargumenten till tal. Det här exemplet utlöser ett undantag om argumentet inte är ett tal.
   När factorial har beräknats (lagras i result variabel av typen long) skrivs det utförliga resultatet ut beroende på variabeln result .

2. På Start-skärmen eller Start-menyn öppnar du ett kommandotolk för Visual Studio Developer och navigerar sedan till mappen som innehåller filen som du skapade.

3. Om du vill kompilera programmet anger du följande kommando:

   dotnet build

   Om programmet inte har några kompileringsfel skapas en binär fil med namnet Factorial.dll .

4. Ange följande kommando för att beräkna faktor 3:

   dotnet run -- 3

5. Om 3 anges på kommandoraden som programmets argument, visas utdata: The factorial of 3 is 6.

Språkspecifikation för C#

Mer information finns i C#-språkspecifikationen. Språkspecifikationen är den slutgiltiga källan för C#-syntax och -användning.

Se även

• System.Environment
• Hur man visar kommandoradsargument