Environment.ExitCode Tulajdonság

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

Environment.CoreCLR.cs

Lekéri vagy beállítja a folyamat kilépési kódját.

public:
 static property int ExitCode { int get(); void set(int value); };

public static int ExitCode { get; set; }

static member ExitCode : int with get, set

Public Shared Property ExitCode As Integer

Tulajdonság értéke

Int32

A kilépési kódot tartalmazó 32 bites aláírt egész szám. Az alapértelmezett érték 0 (nulla), ami azt jelzi, hogy a folyamat sikeresen befejeződött.

Példák

Az alábbiakban egy egyszerű, Double.exe nevű alkalmazás látható, amely parancssori argumentumként a neki átadott egész szám értékét megduplázza. Az érték hibakódokat rendel a tulajdonsághoz a ExitCode hibafeltételek jelzéséhez. Vegye figyelembe, hogy a példa sikeres fordításához hozzá kell adnia egy hivatkozást a System.Numerics.dll szerelvényhez.

using System;
using System.Numerics;

public class Example
{
   private const int ERROR_BAD_ARGUMENTS = 0xA0;
   private const int ERROR_ARITHMETIC_OVERFLOW = 0x216;
   private const int ERROR_INVALID_COMMAND_LINE = 0x667;

   public static void Main()
   {
      string[] args = Environment.GetCommandLineArgs();
      if (args.Length == 1) {
         Environment.ExitCode = ERROR_INVALID_COMMAND_LINE;
      }
      else {
         BigInteger value = 0;
         if (BigInteger.TryParse(args[1], out value))
            if (value <= Int32.MinValue || value >= Int32.MaxValue)
               Environment.ExitCode = ERROR_ARITHMETIC_OVERFLOW;
            else
               Console.WriteLine("Result: {0}", value * 2);

         else
            Environment.ExitCode = ERROR_BAD_ARGUMENTS;
      }
   }
}

open System
open System.Numerics

let ERROR_BAD_ARGUMENTS = 0xA0
let ERROR_ARITHMETIC_OVERFLOW = 0x216
let ERROR_INVALID_COMMAND_LINE = 0x667

let args = Environment.GetCommandLineArgs()
if args.Length = 1 then
    Environment.ExitCode <- ERROR_INVALID_COMMAND_LINE
else
    match BigInteger.TryParse args[1] with
    | true, value ->
        if value <= bigint Int32.MinValue || value >= bigint Int32.MaxValue then
            Environment.ExitCode <- ERROR_ARITHMETIC_OVERFLOW
        else
            printfn $"Result: {value * 2I}"
    | _ ->
        Environment.ExitCode <- ERROR_BAD_ARGUMENTS

Imports System.Numerics

Module Example
   Private Const ERROR_BAD_ARGUMENTS As Integer = &hA0
   Private Const ERROR_ARITHMETIC_OVERFLOW As Integer = &h216
   Private Const ERROR_INVALID_COMMAND_LINE As Integer = &h667
    
   Public Sub Main()
      Dim args() As String = Environment.GetCommandLineArgs()
      If args.Length = 1 Then
         Environment.ExitCode = ERROR_INVALID_COMMAND_LINE  
      Else
         Dim value As BigInteger = 0
         If BigInteger.TryParse(args(1), value) Then
            If value <= Int32.MinValue Or value >= Int32.MaxValue
               Environment.ExitCode = ERROR_ARITHMETIC_OVERFLOW
            Else
               Console.WriteLine("Result: {0}", value * 2)
            End If
         Else
            Environment.ExitCode = ERROR_BAD_ARGUMENTS
         End If     
      End If
   End Sub
End Module

A példa ezután meghívható egy kötegfájlból, például a következőből, amely a parancs használatával akadálymentessé teszi a ERRORLEVEL hibakódokat.

@echo off
Double.exe %1
if errorlevel 1639 goto NoArg
if errorlevel 534 goto Overflow
if errorlevel 160 goto BadArg
if errorlevel 0 echo Completed Successfully
goto :EOF

:NoArg
echo Missing argument
goto :EOF

:Overflow
echo Arithmetic overflow
goto :EOF

:BadArg
echo Invalid argument
goto :EOF

Az alábbiakban a kötegfájl meghívásával előállított mintakimenet látható.

>getdouble 123
Result: 246
Completed Successfully

>getdouble 5912323109093
Arithmetic overflow

>getdouble
Missing argument

>getdouble "a string"
Invalid argument

Vegye figyelembe, hogy a Double.exe kódja megegyezik a következő példával, azzal a kivételsel, hogy az előbbi egy olyan belépési pontot Main határoz meg, amelynek nincs visszatérési értéke, míg ez a példa egy egész számot visszaadó belépési pontot Main határoz meg.

using System;
using System.Numerics;

public class Example
{
   private const int ERROR_SUCCESS = 0;
   private const int ERROR_BAD_ARGUMENTS = 0xA0;
   private const int ERROR_ARITHMETIC_OVERFLOW = 0x216;
   private const int ERROR_INVALID_COMMAND_LINE = 0x667;

   public static int Main()
   {
      string[] args = Environment.GetCommandLineArgs();
      if (args.Length == 1) {
         return ERROR_INVALID_COMMAND_LINE;
      }
      else {
         BigInteger value = 0;
         if (BigInteger.TryParse(args[1], out value))
            if (value <= Int32.MinValue || value >= Int32.MaxValue)
               return ERROR_ARITHMETIC_OVERFLOW;
            else
               Console.WriteLine("Result: {0}", value * 2);

         else
            return ERROR_BAD_ARGUMENTS;
      }
      return ERROR_SUCCESS;
   }
}

open System
open System.Numerics

let ERROR_SUCCESS = 0
let ERROR_BAD_ARGUMENTS = 0xA0
let ERROR_ARITHMETIC_OVERFLOW = 0x216
let ERROR_INVALID_COMMAND_LINE = 0x667

[<EntryPoint>]
let main _ =
    let args = Environment.GetCommandLineArgs()
    if args.Length = 1 then
        ERROR_INVALID_COMMAND_LINE
    else
        match BigInteger.TryParse args[1] with
        | true, value ->
            if value <= bigint Int32.MinValue || value >= bigint Int32.MaxValue then
                ERROR_ARITHMETIC_OVERFLOW
            else
                printfn $"Result: {value * 2I}"
                ERROR_SUCCESS
        | _ ->
            ERROR_BAD_ARGUMENTS

Imports System.Numerics

Module Example
   Private Const ERROR_SUCCESS As Integer = 0
   Private Const ERROR_BAD_ARGUMENTS As Integer = &hA0
   Private Const ERROR_ARITHMETIC_OVERFLOW As Integer = &h216
   Private Const ERROR_INVALID_COMMAND_LINE As Integer = &h667
    
   Public Function Main() As Integer
      Dim args() As String = Environment.GetCommandLineArgs()
      If args.Length = 1 Then
         Return ERROR_INVALID_COMMAND_LINE  
      Else
         Dim value As BigInteger = 0
         If BigInteger.TryParse(args(1), value) Then
            If value <= Int32.MinValue Or value >= Int32.MaxValue
               Return ERROR_ARITHMETIC_OVERFLOW
            Else
               Console.WriteLine("Result: {0}", value * 2)
            End If
         Else
            Return ERROR_BAD_ARGUMENTS
         End If     
      End If
      Return ERROR_SUCCESS
   End Function
End Module

Megjegyzések

Ha a Main metódus visszatér void, ezzel a tulajdonságdal beállíthatja a hívási környezetbe visszaküldött kilépési kódot. Ha Main nem ad vissza void, a rendszer figyelmen kívül hagyja ezt a tulajdonságot. Ennek a tulajdonságnak a kezdeti értéke nulla.

Warning

A ExitCode tulajdonság egy aláírt 32 bites egész szám. Ha meg szeretné akadályozni, hogy a tulajdonság negatív kilépési kódot adjon vissza, ne használjon 0x80000000 vagy annál nagyobb értékeket.

Hiba jelzéséhez használjon nem nulla számot. Az alkalmazásban definiálhatja a saját hibakódjait egy számbavételben, és a forgatókönyv alapján visszaadhatja a megfelelő hibakódot. Adja vissza például az 1 értéket, amely azt jelzi, hogy a szükséges fájl nincs jelen, a 2 érték pedig azt jelzi, hogy a fájl formátuma nem megfelelő. Az Windows operációs rendszer által használt kilépési kódok listáját a Windows dokumentációjában System hibakódjai találja.