Erstellen Sie eine .NET Core-Konsolenanwendung, um eine EXE-Datei auszugeben

Bei einem Konsolenanwendungsprojekt, das auf .NET Core 1.0 abzielt, kann ich nicht herausfinden, wie eine EXE-Datei während der Erstellung ausgegeben wird. Das Projekt läuft gut im Debug.

Ich habe versucht, das Projekt zu veröffentlichen, aber das funktioniert auch nicht. Es ist sinnvoll, da eine EXE-Datei plattformspezifisch wäre, aber es muss einen Weg geben. Meine Suche ergab nur Verweise auf ältere .NET Core-Versionen, die project.json verwendeten.

Wann immer ich baue oder veröffentliche, ist dies alles, was ich bekomme:

Zum Debuggen können Sie die DLL-Datei verwenden. Sie können es mit ausführen dotnet ConsoleApp2.dll. Wenn Sie eine EXE-Datei generieren möchten, müssen Sie eine eigenständige Anwendung generieren.

Um eine eigenständige Anwendung (EXE in Windows) zu generieren, müssen Sie die Ziellaufzeit angeben (die für das Betriebssystem, auf das Sie abzielen, spezifisch ist).

Nur Pre-.NET Core 2.0 : Fügen Sie zunächst die Laufzeitkennung der Ziellaufzeiten in die .csproj-Datei ein ( Liste der unterstützten RIDs ):

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

Der obige Schritt ist ab .NET Core 2.0 nicht mehr erforderlich .

Stellen Sie dann die gewünschte Laufzeit ein, wenn Sie Ihre Anwendung veröffentlichen:

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

UPDATE (31. Oktober 2019)

Für alle, die dies über eine GUI tun möchten und:

• Verwendet Visual Studio 2019
• Hat .NET Core 3.0 installiert (in der neuesten Version von Visual Studio 2019 enthalten)
• Möchte eine einzelne Datei generieren

Hinweis

Beachten Sie die große Dateigröße für eine so kleine Anwendung

Sie können die Eigenschaft "PublishTrimmed" hinzufügen. Die Anwendung enthält nur Komponenten, die von der Anwendung verwendet werden. Achtung : Tun Sie dies nicht, wenn Sie Reflexion verwenden

Erneut veröffentlichen

Vorherigen Post

Für alle, die Visual Studio verwenden und dies über die GUI tun möchten, gehen Sie wie folgt vor:

Das Folgende erzeugt im Ausgabeverzeichnis:

• alle Paketreferenzen
• die Ausgabebaugruppe
• die Bootstrapping-Exe

Es enthält jedoch nicht alle .NET Core-Laufzeitassemblys.

<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>

Ich habe es hier in ein Beispiel eingepackt: https://github.com/SimonCropp/NetCoreConsole

Wenn eine .bat-Datei akzeptabel ist, können Sie eine bat-Datei mit demselben Namen wie die DLL-Datei erstellen (und im selben Ordner ablegen) und dann den folgenden Inhalt einfügen:

dotnet %~n0.dll %*

Dies setzt natürlich voraus, dass auf dem Computer .NET Core installiert und global verfügbar ist.

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

(Diese Antwort stammt aus Chets Kommentar .)

Hier ist meine hackige Problemumgehung: Generieren Sie eine Konsolenanwendung (.NET Framework), die ihren eigenen Namen und ihre eigenen Argumente liest und dann aufruft dotnet [nameOfExe].dll [args] .

Dies setzt natürlich voraus, dass .NET auf dem Zielcomputer installiert ist.

Hier ist der Code. Fühlen Sie sich frei zu kopieren!

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