Main() och kommandoradsargument

Artikel
06/22/2024

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

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

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;

Ö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:

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

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

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

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
Kommandot genererar följande 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