Construire une application console .NET Core pour générer un fichier EXE?

Question

Pour un projet d'application console de ciblage .NET Core 1.0, je ne peux pas comprendre comment obtenir un .exe de sortie lors de la construction. Projet fonctionne très bien en debug.

J'ai essayé de publier le projet mais qui ne fonctionne pas non plus. Sens depuis .exe serait spécifique à la plateforme, mais il doit y avoir un moyen. Mes recherches ont seulement changé le cours de référence pour les plus âgés .Net de Base des versions utilisées projet.json.

Chaque fois que je les construire ou de les publier, c'est tout ce que je reçois.

Answer 1

À des fins de débogage, vous pouvez utiliser le fichier dll. Vous pouvez l'exécuter à l'aide de dotnet ConsoleApp2.dll. Si vous souhaitez générer un fichier exe, vous devez générer une application autonome.

Pour générer une application autonome (exe sous windows), vous devez spécifier la cible de l'exécution (ce qui est spécifique à la version du système cible).

Pre-.NET Core 2.0 uniquement: tout d'Abord, ajoutez le moteur d'exécution de l'identificateur de la cible exécution dans le csproj (liste de prise en charge rid):

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

L'étape ci-dessus n'est plus nécessaire de commencer avec .NET Core 2.0.

Ensuite, réglez le niveau d'exécution lorsque vous publiez votre application:

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

Answer 2

Pour toute personne qui est à l'aide de Visual Studio et veut le faire via l'interface, reportez-vous aux étapes ci-dessous:

Answer 3

Ce qui suit produira, dans le répertoire de sortie,

• toutes les références du paquet
• l'assemblage de sortie
• le bootstrap exe

Mais ne contient pas tous les assemblys d'exécution 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>
 

je l'ai enveloppé dans un exemple ici https://github.com/SimonCropp/NetCoreConsole

Answer 4

Si un fichier .bat est acceptable, vous pouvez créer un fichier bat avec le même nom que la dll (et le placer dans le même dossier), puis coller le contenu suivant:

dotnet %0.dll %*

Évidemment, cela suppose que .NET Core est installé sur la machine.

Appelez-le sans la partie '.bat'. c'est-à-dire: c:\>"path\to\program" -args blah (cette réponse est dérivée du commentaire de Chet)

Answer 5

Voici ma solution de contournement: générez une application console (.NET Framework) qui lit son propre nom et ses arguments, puis appelle dotnet [nameOfExe].dll [args]

Bien entendu, cela suppose que dotnet est installé sur la machine cible.

Voici le code, n'hésitez pas à copier!

 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();
        }
    }
}