Main() y argumentos de línea de comandos

El tiempo de ejecución llama al método cuando se inicia una aplicación de C#. El método es el punto de entrada de una aplicación de C#

Un programa de C# solo puede tener un punto de entrada. Si tiene más de una clase con un método, debe usar la opción del compilador StartupObject al compilar el programa para especificar qué método actúa como punto de entrada. Para obtener más información, consulte StartupObject (opciones del compilador de C#). En el ejemplo siguiente se muestra el número de argumentos de la línea de comandos como su primera acción:

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

También puede usar instrucciones de nivel superior en un archivo como punto de entrada para la aplicación. Al igual que el método , las instrucciones de nivel superior pueden devolver valores y acceder a los argumentos de la línea de comandos. Para más información, consulte Instrucciones de nivel superior. En el ejemplo siguiente se usa un bucle para mostrar los argumentos de la línea de comandos mediante la variable y al final del programa se devuelve un código correcto ():

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;

A partir de C# 14, los programas pueden ser aplicaciones basadas en archivos, donde un único archivo contiene el programa. Ejecute las aplicaciones basadas en archivos usando el comando o utilizando la directiva como primera línea (solo shells de Unix).

Información general

• El método es el punto de entrada de un programa ejecutable. Es donde comienza y termina el control de programa.
• Debe declarar dentro de una clase o estructura. La envolvente puede ser .
• debe ser .
• puede tener cualquier modificador de acceso.
• puede devolver , , o .
• Si y solo si devuelve un o un , la declaración de puede incluir el modificador . Esta regla excluye específicamente un método .
• Puede declarar el método con o sin un parámetro que contenga argumentos de línea de comandos. Al usar Visual Studio para crear aplicaciones Windows, puede agregar el parámetro manualmente o usar el método GetCommandLineArgs() para obtener los argumentos de la línea de comandos. Los parámetros son argumentos de línea de comandos sin indexación. A diferencia de C y C++, el nombre del programa no se trata como el primer argumento de línea de comandos de la matriz, pero es el primer elemento del método.

En la lista siguiente, se muestran las declaraciones más comunes:

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) { }

Los ejemplos anteriores no especifican un modificador de acceso, por lo que son implícitamente de forma predeterminada. Puede especificar cualquier modificador de acceso explícito.

Valores devueltos por Main()

Puede devolver un objeto desde el método si lo define de una de las siguientes maneras:

Si no se usa el valor devuelto de , devuelve o permite un código ligeramente más sencillo.

Pero, si se devuelve o , el programa puede comunicar información de estado a otros programas o scripts que invocan el archivo ejecutable.

En el ejemplo siguiente se muestra cómo se puede acceder al código de salida para el proceso.

En este ejemplo se usan .NET Core herramientas de línea de comandos. Si no está familiarizado con las herramientas de línea de comandos de .NET Core, puede obtener información sobre ellas en este artículo get-started.

Cree una aplicación mediante la ejecución de . Modifique el método en Program.cs como se indica a continuación:

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

Recuerde guardar este programa como MainReturnValTest.cs.

Al ejecutar un programa en Windows, el sistema almacena cualquier valor devuelto de la función />

Puede compilar la aplicación mediante el comando de la CLI de dotnet.

Después, cree un script de PowerShell para ejecutar la aplicación y mostrar el resultado. Pegue el código siguiente en un archivo de texto y guárdelo como en la carpeta que contiene el proyecto. Ejecute el script de PowerShell escribiendo en PowerShell.

Dado que el código devuelve cero, el archivo por lotes informa de un éxito. Sin embargo, si cambia MainReturnValTest.cs para devolver un valor distinto de cero y, a continuación, vuelve a compilar el programa, la ejecución posterior del script de PowerShell notifica un error.

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

Valores devueltos asincrónicos de Main

Cuando se declara un valor devuelto para , el compilador genera el código reutilizable para llamar a métodos asincrónicos en :

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

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

En ambos ejemplos, el cuerpo principal del programa está dentro del cuerpo del método.

Una ventaja de declarar como es que el compilador siempre genera el código correcto.

Cuando el punto de entrada de la aplicación devuelve o , el compilador genera un nuevo punto de entrada que llama al método de punto de entrada declarado en el código de la aplicación. Suponiendo que este punto de entrada se denomina , el compilador genera el código siguiente para estos puntos de entrada:

• da como resultado el compilador que emite el equivalente de .
• da como resultado el compilador que emite el equivalente de .
• da como resultado el compilador que emite el equivalente de .
• da como resultado el compilador que emite el equivalente de .

Argumentos de la línea de comandos

Puede enviar argumentos al método definiéndolo de una de las siguientes maneras:

Si no usa los argumentos, puede omitir de la declaración de método para código ligeramente más sencillo:

El parámetro del método es una matriz que representa los argumentos de la línea de comandos. Normalmente, se determina si existen argumentos probando la propiedad , por ejemplo:

if (args.Length == 0)
{
    System.Console.WriteLine("Please enter a numeric argument.");
    return 1;
}

También puede convertir los argumentos de cadena en tipos numéricos mediante la clase o el método . Por ejemplo, la siguiente instrucción convierte la en un número mediante el método :

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

También es posible usar el tipo de C#, cual es un alias de .

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

También puede usar el método de la clase para hacer lo mismo:

long num = Convert.ToInt64(s);

Para obtener más información, vea y .

En el ejemplo siguiente se muestra cómo usar argumentos de la línea de comandos en una aplicación de consola. La aplicación toma un argumento en tiempo de ejecución, lo convierte en un entero y calcula el factorial del número. Si no se proporciona ningún argumento, la aplicación emite un mensaje en el que se explica el uso correcto del programa.

Para compilar y ejecutar la aplicación desde un terminal, siga estos pasos:

1. Pegue el código siguiente en cualquier editor de texto, y después guarde el archivo como archivo de texto con el nombre 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;
    }
}

Al principio del método, el programa comprueba si no se proporcionaron argumentos de entrada comparando la longitud del argumento con y muestra la ayuda si no se encuentra ningún argumento.
Si se proporcionan argumentos ( es mayor que 0), el programa intenta convertir los argumentos de entrada en números. En este ejemplo se produce una excepción si el argumento no es un número.
Una vez calculado el factorial (almacenado en de la variable de tipo ), el resultado detallado se imprime en función de la variable .

1. En la pantalla Start o Start, abra un Visual Studio Developer Command Prompt y vaya a la carpeta que contiene el archivo que creó.

2. Para compilar la aplicación, escriba el siguiente comando:

   dotnet build

   Si la aplicación no tiene errores de compilación, el proceso de compilación crea un archivo binario denominado Factorial.dll.

3. Escriba el siguiente comando para calcular el factorial de 3:

   dotnet run -- 3

4. Si escribe 3 en la línea de comandos como argumento del programa, la salida lee:

Especificación del lenguaje C#

Para obtener más información, consulte la Especificación del lenguaje C#. La especificación del lenguaje es la fuente definitiva de la sintaxis y el uso de C#.

Vea también

• System.Environment
• Procedimiento para mostrar argumentos de la línea de comandos