Environment.ExitCode Property
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Gets or sets the exit code of the process.
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
Property Value
A 32-bit signed integer containing the exit code. The default value is 0 (zero), which indicates that the process completed successfully.
Examples
The following is a simple app named Double.exe that doubles an integer value passed to it as a command-line argument. The value assigns error codes to the ExitCode property to indicate error conditions. Note that you must add a reference to the System.Numerics.dll assembly to successfully compile the example.
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
The example can then be invoked from a batch file such as the following, which makes its error codes accessible by using the ERRORLEVEL
command.
@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
The following shows some sample output produced by invoking the batch file.
>getdouble 123
Result: 246
Completed Successfully
>getdouble 5912323109093
Arithmetic overflow
>getdouble
Missing argument
>getdouble "a string"
Invalid argument
Note that code for Double.exe is identical in function to the following example, except that the former defines an entry point named Main
that has no return value, whereas this example defines an entry point named Main
that returns an integer.
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
Remarks
If the Main
method returns void
, you can use this property to set the exit code that will be returned to the calling environment. If Main
does not return void
, this property is ignored. The initial value of this property is zero.
Warning
The ExitCode property is a signed 32-bit integer. To prevent the property from returning a negative exit code, you should not use values greater than or equal to 0x80000000.
Use a non-zero number to indicate an error. In your application, you can define your own error codes in an enumeration, and return the appropriate error code based on the scenario. For example, return a value of 1 to indicate that the required file is not present and a value of 2 to indicate that the file is in the wrong format. For a list of exit codes used by the Windows operating system, see System Error Codes in the Windows documentation.