Dela via

Main() och kommandoradsargument

Tips

Är du nybörjare på att utveckla programvara? Börja med självstudierna Komma igång först. Dessa handledningar använder toppnivåuttalanden, vilket är enklare för nya appar.

Arbetar du med en befintlig kodbas? Många befintliga program använder en explicit Main metod. Den här artikeln förklarar hur den fungerar och hur den används effektivt.

När du startar ett C#-program anropar körmiljön Main metoden. Metoden Main är startpunkten för ett C#-program.

Ett C#-program kan bara ha en startpunkt. Om du har mer än en klass med en Main metod måste du använda kompileringsalternativet StartupObject när du kompilerar programmet 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);
    }
}

Översikt

Metoden Main är startpunkten för ett körbart program. När ditt program startar anropar körningen Main innan någon annan kod körs. När Main returnerar avslutas programmet. Du deklarerar Main med följande regler:

  • Du måste deklarera Main i en klass eller struct. Det omgivande class kan vara static.
  • Main måste vara static.
  • Main kan ha alla åtkomstmodifierare.
  • Main kan returnera void, int, Taskeller 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.
  • Du kan deklarera Main metoden 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 är 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 permutationer av Main deklarationer:

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. Du kan ange valfri explicit åtkomstmodifierare.

I följande tabell sammanfattas alla giltiga Main signaturer och när var och en ska användas:

Main deklaration Använder args Innehåller await Returnerar slutkod
static void Main() No No No
static int Main() No No Ja
static void Main(string[] args) Ja No No
static int Main(string[] args) Ja No Ja
static async Task Main() No Ja No
static async Task<int> Main() No Ja Ja
static async Task Main(string[] args) Ja Ja No
static async Task<int> Main(string[] args) Ja Ja Ja

Välj den enklaste signaturen som passar dina behov. Om du inte behöver kommandoradsargument utelämnar du parametern string[] args . Om du inte behöver returnera en slutkod använder du void eller Task. Om du behöver anropa asynkrona metoder använder du async med en Task eller Task<int> returtyp.

Returvärden för Main()

När du returnerar int eller Task<int>kan programmet skicka statusinformation till andra program eller skript som kör den körbara filen. Ett returvärde 0 för innebär vanligtvis framgång, och ett värde som inte är noll innebär att det finns ett fel.

I följande exempel returneras en slutkod:

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

När du har kört programmet kan du kontrollera slutkoden. I PowerShell använder du $LastExitCode. I en batchfil eller ett shell-skript använder du %ERRORLEVEL%.

Om din Main metod använder awaitdeklarerar du den som async med en Task eller Task<int> returtyp. Körningen anropar Main och väntar på att Task ska slutföras innan processen avslutas. Returtypen kan inte vara void eller int eftersom async modifieraren kräver en returtyp som körningen kan vänta på och voidint inte representerar pågående arbete, så processen kan avslutas innan asynkrona åtgärder slutförs. Använd Task när du inte behöver någon slutkod eller Task<int> när du gör det:

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

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

Kommandoradsargument

Inkludera en string[] args parameter i Main deklarationen för att acceptera kommandoradsargument. Om du inte behöver dem utelämnar du parametern. Parametern args är en String matris som aldrig är null – om inga argument anges är den Length noll.

Du kan konvertera strängargument till andra typer med hjälp Parse av eller Convert:

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

Tips

Det kan vara komplicerat att parsa kommandoradsargument. Överväg att använda biblioteket System.CommandLine för att förenkla processen.

Ett fungerande exempel finns i Visa kommandoradsargument.

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.

Relaterat innehåll

  • Last updated on