Compile la aplicación de consola .NET Core para generar un EXE

Para un proyecto de aplicación de consola dirigido a .NET Core 1.0, no puedo entender cómo obtener un .exe para generar durante la compilación. El proyecto funciona bien en depuración.

He intentado publicar el proyecto, pero eso tampoco funciona. Tiene sentido ya que un archivo EXE sería específico de la plataforma, pero debe haber una manera. Mis búsquedas solo han hecho referencia a versiones anteriores de .NET Core que usaban project.json.

Cada vez que construyo o publico, esto es todo lo que obtengo:

Para fines de depuración, puede usar el archivo DLL. Puedes ejecutarlo usando dotnet ConsoleApp2.dll. Si desea generar un archivo EXE, debe generar una aplicación autónoma.

Para generar una aplicación autónoma (EXE en Windows), debe especificar el tiempo de ejecución de destino (que es específico del sistema operativo al que se dirige).

Solo antes de .NET Core 2.0 : primero, agregue el identificador de tiempo de ejecución de los tiempos de ejecución de destino en el archivo .csproj ( lista de RID compatibles ):

<PropertyGroup>
    <RuntimeIdentifiers>win10-x64;ubuntu.16.10-x64</RuntimeIdentifiers>
</PropertyGroup>

El paso anterior ya no es necesario a partir de .NET Core 2.0 .

Luego, configure el tiempo de ejecución deseado cuando publique su aplicación:

dotnet publish -c Release -r win10-x64
dotnet publish -c Release -r ubuntu.16.10-x64

ACTUALIZACIÓN (31-OCT-2019)

Para cualquiera que quiera hacer esto a través de una GUI y:

• Está usando Visual Studio 2019
• Tiene instalado .NET Core 3.0 (incluido en la última versión de Visual Studio 2019)
• Quiere generar un solo archivo

Nota

Observe el tamaño de archivo grande para una aplicación tan pequeña

Puede agregar la propiedad "PublishTrimmed". La aplicación solo incluirá componentes utilizados por la aplicación. Precaución : no hagas esto si estás usando la reflexión

Publicar de nuevo

Publicación anterior

Para cualquiera que use Visual Studio y quiera hacer esto a través de la GUI, consulte los pasos a continuación:

Lo siguiente producirá, en el directorio de salida,

• todas las referencias del paquete
• el conjunto de salida
• el exe bootstrapping

Pero no contiene todos los ensamblados de tiempo de ejecución de .NET Core.

<PropertyGroup>
  <Temp>$(SolutionDir)\packaging\</Temp>
</PropertyGroup>

<ItemGroup>
  <BootStrapFiles Include="$(Temp)hostpolicy.dll;$(Temp)$(ProjectName).exe;$(Temp)hostfxr.dll;"/>
</ItemGroup>

<Target Name="GenerateNetcoreExe"
        AfterTargets="Build"
        Condition="'$(IsNestedBuild)' != 'true'">
  <RemoveDir Directories="$(Temp)" />
  <Exec
    ConsoleToMSBuild="true"
    Command="dotnet build $(ProjectPath) -r win-x64 /p:CopyLocalLockFileAssemblies=false;IsNestedBuild=true --output $(Temp)" >
    <Output TaskParameter="ConsoleOutput" PropertyName="OutputOfExec" />
  </Exec>
  <Copy
    SourceFiles="@(BootStrapFiles)"
    DestinationFolder="$(OutputPath)"
  />

</Target>

Lo envolví en una muestra aquí: https://github.com/SimonCropp/NetCoreConsole

Si un archivo .bat es aceptable, puede crear un archivo bat con el mismo nombre que el archivo DLL (y colocarlo en la misma carpeta), luego pegue el siguiente contenido:

dotnet %~n0.dll %*

Obviamente, esto supone que la máquina tiene .NET Core instalado y disponible a nivel mundial.

c:\> "path\to\batch\file" -args blah

(Esta respuesta se deriva del comentario de Chet ).

Aquí está mi solución alternativa: generar una aplicación de consola (.NET Framework) que lea su propio nombre y argumentos, y luego llame dotnet [nameOfExe].dll [args].

Por supuesto, esto supone que .NET está instalado en la máquina de destino.

Aquí está el código. ¡Siéntase libre de copiar!

using System;
using System.Diagnostics;
using System.Text;

namespace dotNetLauncher
{
    class Program
    {
        /*
            If you make .NET Core applications, they have to be launched like .NET blah.dll args here
            This is a convenience EXE file that launches .NET Core applications via name.exe
            Just rename the output exe to the name of the .NET Core DLL file you wish to launch
        */
        static void Main(string[] args)
        {
            var exePath = AppDomain.CurrentDomain.BaseDirectory;
            var exeName = AppDomain.CurrentDomain.FriendlyName;
            var assemblyName = exeName.Substring(0, exeName.Length - 4);
            StringBuilder passInArgs = new StringBuilder();
            foreach(var arg in args)
            {
                bool needsSurroundingQuotes = false;
                if (arg.Contains(" ") || arg.Contains("\""))
                {
                    passInArgs.Append("\"");
                    needsSurroundingQuotes = true;
                }
                passInArgs.Append(arg.Replace("\"","\"\""));
                if (needsSurroundingQuotes)
                {
                    passInArgs.Append("\"");
                }

                passInArgs.Append(" ");
            }
            string callingArgs = $"\"{exePath}{assemblyName}.dll\" {passInArgs.ToString().Trim()}";

            var p = new Process
            {
                StartInfo = new ProcessStartInfo("dotnet", callingArgs)
                {
                    UseShellExecute = false
                }
            };

            p.Start();
            p.WaitForExit();
        }
    }
}