.net-core - instal - net core 3




¿Construir la aplicación de consola.NET Core para generar un EXE? (4)

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 tampoco funciona. Tiene sentido ya que .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.


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

Por supuesto, esto supone que dotnet 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 apps, they have to be launched like dotnet blah.dll args here
            This is a convenience exe that launches .net core apps via name.exe
            Just rename the output exe to the name of the .net core dll 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();
        }
    }
}

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 netcore

<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


Para fines de depuración, puede usar el archivo dll. Puede ejecutarlo con dotnet ConsoleApp2.dll . Si desea generar un 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 csproj ( lista de eliminación admitida ):

<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

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

dotnet %0.dll %*

Obviamente, esto supone que la máquina tiene instalado .NET Core.

Llámalo sin la parte '.bat'. es decir: c:\>"path\to\program" -args blah (esta respuesta se deriva del comentario de Chet)





.net-core