Main() och kommandoradsargument

Artikel
01/29/2025

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).
Nedan visas exemplet där den första raden som körs visar antalet kommandoradsargument:

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

Du kan också använda topnivå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 Top-level-instruktioner.
I följande exempel används en foreach-loop för att visa kommandoradsargumenten med 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;

Ö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. Omslutningen class kan vara static.
Main måste vara static.
Main kan ha alla åtkomstmodifierare (förutom file).
Main kan antingen ha typen void, int, Taskeller Task<int> retur.
Om och endast om Main returnerar en Task eller Task<int>kan deklarationen av Main innehålla async modifieraren. Detta 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 är typiskt, men det är möjligt att ange en explicit åtkomstmodifierare.

Dricks

Tillägget av async och Task, Task<int> returnerar typer förenklar programkoden när konsolprogram behöver starta och await asynkrona åtgärder i Main.

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:

`Main` deklaration	`Main` metodkod
`static int Main()`	Ingen användning av `args` eller `await`
`static int Main(string[] args)`	Använder `args`, ingen användning av `await`
`static async Task<int> Main()`	Ingen användning av `args`, använder `await`
`static async Task<int> Main(string[] args)`	Användningsområden `args` och `await`

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

`Main` deklaration	`Main` metodkod
`static void Main()`	Ingen användning av `args` eller `await`
`static void Main(string[] args)`	Använder `args`, ingen användning av `await`
`static async Task Main()`	Ingen användning av `args`, använder `await`
`static async Task Main(string[] args)`	Användningsområden `args` och `await`

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 känner till kommandoradsverktygen för .NET Core kan du lära dig mer om dem i den här komma 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 skapa programmet med hjälp av cli-kommandotdotnet build dotnet.

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 värde som inte är noll och sedan kompilera om programmet, rapporterar efterföljande körning av PowerShell-skriptet fel.

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

Async Main-returvärden

När du deklarerar ett async returvärde för Maingenererar kompilatorn exempelkoden för att anropa asynkrona metoder i Main. Om du inte anger nyckelordet async måste du skriva koden själv, som du ser i följande exempel. Koden i exemplet säkerställer att programmet körs tills den asynkrona åtgärden har slutförts:

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

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

Den här exempelkoden kan ersättas med:

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();

Kommentar

Om exemplen använde async modifieraren på Main metoden skulle kompilatorn generera samma kod.

Kommandoradsargument

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

`Main` deklaration	`Main` metodkod
`static void Main(string[] args)`	Inget returvärde, ingen användning av `await`
`static int Main(string[] args)`	Returvärde, ingen användning av `await`
`static async Task Main(string[] args)`	Inget returvärde, använder `await`
`static async Task<int> Main(string[] args)`	Returvärde, använder `await`

Om argumenten inte används kan du utelämna args något enklare kod från metoddeklarationen:

`Main` deklaration	`Main` metodkod
`static void Main()`	Inget returvärde, ingen användning av `await`
`static int Main()`	Returvärde, ingen användning av `await`
`static async Task Main()`	Inget returvärde, använder `await`
`static async Task<int> Main()`	Returvärde, använder `await`

Kommentar

Du kan också använda Environment.CommandLine eller Environment.GetCommandLineArgs för att komma åt kommandoradsargumenten från valfri punkt i en konsol eller ett Windows Forms-program. Om du vill aktivera kommandoradsargument i metoddeklarationen Main i ett Windows Forms-program måste du manuellt ändra deklarationen för Main. Koden som genereras av Windows Forms-designern skapar Main utan en indataparameter.

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

Dricks

Matrisen args får inte vara null. Därför är det säkert att komma åt egenskapen Length utan null-kontroll.

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.

Dricks

Det kan vara komplicerat att parsa kommandoradsargument. Överväg att använda System.CommandLine-biblioteket (för närvarande i betaversion) för att förenkla processen.

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:

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 argument med 0 och visar hjälpen om inget argument hittas.
Om argument anges (args.Length är större än 0) försöker programmet konvertera indataargumenten till tal. Detta utlöser ett undantag om argumentet inte är ett tal.
När factorial beräknas (lagras i result variabel av typen long) skrivs det utförliga resultatet ut beroende på variabeln result.

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.
Ange följande kommando för att kompilera programmet.

dotnet build

Om programmet inte har några kompileringsfel skapas en körbar fil med namnet Factorial.exe .
Ange följande kommando för att beräkna faktor 3:

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

Kommentar

När du kör ett program i Visual Studio kan du ange kommandoradsargument i felsökningssidan , Project Designer.

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.

Dela via

Main() och kommandoradsargument

Översikt

Returvärden för Main()

Async Main-returvärden

Kommandoradsargument

Språkspecifikation för C#

Se även

Ytterligare resurser