Panoramica della pubblicazione delle applicazioni .NET Core.NET Core application publishing overview

Le applicazioni create con .NET Core possono essere pubblicate in due diverse modalità e la modalità influisce sulla modalità di esecuzione dell'app da parte di un utente.Applications you create with .NET Core can be published in two different modes, and the mode affects how a user runs your app.

La pubblicazione dell'app come autonoma produce un'applicazione che include il runtime e le librerie .NET Core, l'applicazione e le relative dipendenze.Publishing your app as self-contained produces an application that includes the .NET Core runtime and libraries, and your application and its dependencies. Gli utenti dell'applicazione possono eseguirlo in un computer in cui non è installato il runtime di .NET Core.Users of the application can run it on a machine that doesn't have the .NET Core runtime installed.

La pubblicazione dell'app come dipendente dal runtime (precedentemente nota come dipendente dal framework) produce un'applicazione che include solo l'applicazione stessa e le relative dipendenze.Publishing your app as runtime-dependent (previously known as framework-dependent) produces an application that includes only your application itself and its dependencies. Gli utenti dell'applicazione devono installare separatamente il runtime di .NET Core.Users of the application have to separately install the .NET Core runtime.

Entrambi i modi di pubblicazione producono un eseguibile specifico della piattaforma per impostazione predefinita.Both publishing modes produce a platform-specific executable by default. Le applicazioni dipendenti dal runtime possono essere create senza un eseguibile e sono multipiattaforma.Runtime-dependent applications can be created without an executable, and these applications are cross-platform.

Quando viene prodotto un eseguibile, è possibile specificare la piattaforma di destinazione con un identificatore di runtime (RID).When an executable is produced, you can specify the target platform with a runtime identifier (RID). Per ulteriori informazioni sui RID, vedere .NET Core RID Catalog.For more information about RIDs, see .NET Core RID Catalog.

Nella tabella seguente vengono descritti i comandi usati per pubblicare un'app come dipendente dal runtime o indipendente per ogni versione dell'SDK:The following table outlines the commands used to publish an app as runtime-dependent or self-contained, per SDK version:The following table outlines the commands used to publish an app as runtime-dependent or self-contained, per SDK version:

TypeType SDK 2.1SDK 2.1 SDK 3.xSDK 3.x ComandoCommand
eseguibile dipendente dal runtime per la piattaforma corrente.runtime-dependent executable for the current platform. ✔️✔️ dotnet publish
eseguibile dipendente dal runtime per una piattaforma specifica.runtime-dependent executable for a specific platform. ✔️✔️ dotnet publish -r <RID> --self-contained false
binario multipiattaforma dipendente dal runtime.runtime-dependent cross-platform binary. ✔️✔️ ✔️✔️ dotnet publish
file eseguibile indipendente.self-contained executable. ✔️✔️ ✔️✔️ dotnet publish -r <RID>

Per ulteriori informazioni, vedere Comando di pubblicazione dotnet di .NET Core.For more information, see .NET Core dotnet publish command.

Produrre un eseguibileProduce an executable

Gli eseguibili non sono multipiattaforma.Executables aren't cross-platform. Sono specifici di un sistema operativo e dell'architettura della CPU.They're specific to an operating system and CPU architecture. Quando pubblichi l'app e crei un eseguibile, puoi pubblicarla come autonoma o dipendente dal runtime.When publishing your app and creating an executable, you can publish the app as self-contained or runtime-dependent. La pubblicazione di un'app come autonoma include il runtime di .NET Core con l'app e gli utenti dell'app non devono preoccuparsi di installare .NET Core prima di eseguire l'app.Publishing an app as self-contained includes the .NET Core runtime with the app, and users of the app don't have to worry about installing .NET Core before running the app. Le app pubblicate come dipendenti dal runtime non includono il runtime e le librerie di .NET Core; sono incluse solo le dipendenze dell'app e di terze parti.Apps published as runtime-dependent don't include the .NET Core runtime and libraries; only the app and 3rd-party dependencies are included.

I seguenti comandi producono un eseguibile:The following commands produce an executable:

TypeType SDK 2.1SDK 2.1 SDK 3.xSDK 3.x ComandoCommand
eseguibile dipendente dal runtime per la piattaforma corrente.runtime-dependent executable for the current platform. ✔️✔️ dotnet publish
eseguibile dipendente dal runtime per una piattaforma specifica.runtime-dependent executable for a specific platform. ✔️✔️ dotnet publish -r <RID> --self-contained false
file eseguibile indipendente.self-contained executable. ✔️✔️ ✔️✔️ dotnet publish -r <RID>

Produrre un binario multipiattaformaProduce a cross-platform binary

I file binari multipiattaforma vengono creati quando si pubblica l'app come dipendente dal runtime,sotto forma di file dll.Cross-platform binaries are created when you publish your app as runtime-dependent, in the form of a dll file. Il file dll viene denominato in base al progetto.The dll file is named after your project. Ad esempio, se si dispone di un'app denominata word_reader, viene creato un file denominato word_reader.dll.For example, if you have an app named word_reader, a file named word_reader.dll is created. Le app pubblicate in dotnet <filename.dll> questo modo vengono eseguite con il comando e possono essere eseguite su qualsiasi piattaforma.Apps published in this way are run with the dotnet <filename.dll> command and can be run on any platform.

I file binari multipiattaforma possono essere eseguiti su qualsiasi sistema operativo, purché il runtime .NET Core di destinazione sia già installato.Cross-platform binaries can be run on any operating system as long as the targeted .NET Core runtime is already installed. Se il runtime .NET Core di destinazione non è installato, l'app può essere eseguita usando un runtime più recente se l'app è configurata per il rollforward.If the targeted .NET Core runtime isn't installed, the app may run using a newer runtime if the app is configured to roll-forward. Per altre informazioni, consultate Avanzamento delle app dipendenti dal runtime.For more information, see runtime-dependent apps roll forward.

Il comando seguente produce un binario multipiattaforma:The following command produces a cross-platform binary:The following command produces a cross-platform binary:

TypeType SDK 2.1SDK 2.1 SDK 3.xSDK 3.x ComandoCommand
binario multipiattaforma dipendente dal runtime.runtime-dependent cross-platform binary. ✔️✔️ ✔️✔️ dotnet publish

Pubblica dipendente dal runtimePublish runtime-dependent

Le app pubblicate come dipendenti dal runtime sono multipiattaforma e non includono il runtime .NET Core.Apps published as runtime-dependent are cross-platform and don't include the .NET Core runtime.Apps published as runtime-dependent are cross-platform and don't include the .NET Core runtime. L'utente dell'app deve installare il runtime di .NET Core.The user of your app is required to install the .NET Core runtime.

La pubblicazione di un'app come dipendente dal runtime produce un file binario multipiattaforma come file dll e un eseguibile specifico della piattaforma destinato alla piattaforma corrente.Publishing an app as runtime-dependent produces a cross-platform binary as a dll file, and a platform-specific executable that targets your current platform. La dll è multipiattaforma mentre l'eseguibile non lo è.The dll is cross-platform while the executable isn't. Ad esempio, se si pubblica un'app denominata word_reader e Windows di destinazione, viene creato un eseguibile word_reader.exe insieme a word_reader.dll.For example, if you publish an app named word_reader and target Windows, a word_reader.exe executable is created along with word_reader.dll. Quando si ha come destinazione Linux o macOS, viene creato un eseguibile word_reader insieme a word_reader.dll.When targeting Linux or macOS, a word_reader executable is created along with word_reader.dll. Per ulteriori informazioni sui RID, vedere .NET Core RID Catalog.For more information about RIDs, see .NET Core RID Catalog.

Importante

.NET Core SDK 2.1 non produce eseguibili specifici della piattaforma quando si pubblica un'app dipendente dal runtime..NET Core SDK 2.1 doesn't produce platform-specific executables when you publish an app runtime-dependent.

Il file binario multipiattaforma dell'app dotnet <filename.dll> può essere eseguito con il comando e può essere eseguito su qualsiasi piattaforma.The cross-platform binary of your app can be run with the dotnet <filename.dll> command, and can be run on any platform. Se l'app usa un pacchetto NuGet con implementazioni specifiche della piattaforma, le dipendenze di tutte le piattaforme vengono copiate nella cartella di pubblicazione insieme all'app.If the app uses a NuGet package that has platform-specific implementations, all platforms' dependencies are copied to the publish folder along with the app.

È possibile creare un eseguibile per -r <RID> --self-contained false una dotnet publish piattaforma specifica passando i parametri al comando.You can create an executable for a specific platform by passing the -r <RID> --self-contained false parameters to the dotnet publish command. Quando -r il parametro viene omesso, viene creato un eseguibile per la piattaforma corrente.When the -r parameter is omitted, an executable is created for your current platform. Tutti i pacchetti NuGet con dipendenze specifiche della piattaforma per la piattaforma di destinazione vengono copiati nella cartella di pubblicazione.Any NuGet packages that have platform-specific dependencies for the targeted platform are copied to the publish folder.

VantaggiAdvantages

  • Distribuzione di piccole dimensioniSmall deployment
    Vengono distribuiti solo l'app e le relative dipendenze.Only your app and its dependencies are distributed. Il runtime e le librerie di .NET Core vengono installati dall'utente e tutte le app condividono il runtime.The .NET Core runtime and libraries are installed by the user and all apps share the runtime.

  • MultipiattaformaCross-platform
    La tua app e qualsiasi file . La libreria basata su NET viene eseguita su altri sistemi operativi.Your app and any .NET-based library runs on other operating systems. Non è necessario definire una piattaforma di destinazione per l'app.You don't need to define a target platform for your app. Per informazioni sul formato di file .NET, vedere Formato file assembly .NET.For information about the .NET file format, see .NET Assembly File Format.

  • Utilizza l'ultimo runtime con patchUses the latest patched runtime
    L'app usa il runtime più recente (all'interno della famiglia principale e minore di destinazione di .NET Core) installato nel sistema di destinazione.The app uses the latest runtime (within the targeted major-minor family of .NET Core) installed on the target system. Ciò significa che l'app usa automaticamente la versione con patch più recente del runtime di .NET Core.This means your app automatically uses the latest patched version of the .NET Core runtime. Questo comportamento predefinito può essere sottoposto a override.This default behavior can be overridden. Per altre informazioni, consultate Avanzamento delle app dipendenti dal runtime.For more information, see runtime-dependent apps roll forward.

SvantaggiDisadvantages

  • Richiede la preinstallazione del runtimeRequires pre-installing the runtime
    L'app può essere eseguita solo se la versione di .NET Core di destinazione dell'app è già installata nel sistema host.Your app can run only if the version of .NET Core your app targets is already installed on the host system. È possibile configurare il comportamento di rollforward per l'app per richiedere una versione specifica di .NET Core o consentire una versione più recente di .NET Core.You can configure roll-forward behavior for the app to either require a specific version of .NET Core or allow a newer version of .NET Core.You can configure roll-forward behavior for the app to either require a specific version of .NET Core or allow a newer version of .NET Core. Per altre informazioni, consultate Avanzamento delle app dipendenti dal runtime.For more information, see runtime-dependent apps roll forward.

  • .NET Core può cambiare.NET Core may change
    È possibile che il runtime di .NET Core e le librerie vengano aggiornati nel computer in cui viene eseguita l'app.It's possible for the .NET Core runtime and libraries to be updated on the machine where the app is run. In rari casi, ciò può modificare il comportamento dell'app se si usano le librerie .NET Core, operazione pari alla maggior parte delle app.In rare cases, this may change the behavior of your app if you use the .NET Core libraries, which most apps do. Puoi configurare il modo in cui l'app usa le versioni più recenti di .NET Core.You can configure how your app uses newer versions of .NET Core.You can configure how your app uses newer versions of .NET Core. Per altre informazioni, consultate Avanzamento delle app dipendenti dal runtime.For more information, see runtime-dependent apps roll forward.

Il seguente svantaggio si applica solo a .NET Core 2.1 SDK.The following disadvantage only applies to .NET Core 2.1 SDK.

  • Usare dotnet il comando per avviare l'appUse the dotnet command to start the app
    Gli utenti dotnet <filename.dll> devono eseguire il comando per avviare l'app.Users must run the dotnet <filename.dll> command to start your app. .NET Core 2.1 SDK non produce eseguibili specifici della piattaforma per le app pubblicate dipendenti dal runtime..NET Core 2.1 SDK doesn't produce platform-specific executables for apps published runtime-dependent.

EsempiExamples

Pubblicare un'app dipendente dal runtime multipiattaforma.Publish an app cross-platform runtime-dependent. Viene creato un eseguibile destinato alla piattaforma corrente insieme al file dll.An executable that targets your current platform is created along with the dll file.

dotnet publish

Pubblicare un'app dipendente dal runtime multipiattaforma.Publish an app cross-platform runtime-dependent. Viene creato un eseguibile Linux a 64 bit insieme al file dll.A Linux 64-bit executable is created along with the dll file. Questo comando non funziona con .NET Core SDK 2.1.This command doesn't work with .NET Core SDK 2.1.

dotnet publish -r linux-x64 --self-contained false

Pubblicare autonomamentePublish self-contained

La pubblicazione dell'app come autonoma produce un eseguibile specifico della piattaforma.Publishing your app as self-contained produces a platform-specific executable. La cartella di pubblicazione dell'output contiene tutti i componenti dell'app, incluse le librerie .NET Core e il runtime di destinazione.The output publishing folder contains all components of the app, including the .NET Core libraries and target runtime. L'app è isolata da altre app .NET Core e non usa un runtime condiviso installato localmente.The app is isolated from other .NET Core apps and doesn't use a locally installed shared runtime. L'utente dell'app non è necessario per scaricare e installare .NET Core.The user of your app isn't required to download and install .NET Core.

Il file binario eseguibile viene prodotto per la piattaforma di destinazione specificata.The executable binary is produced for the specified target platform. Ad esempio, se si dispone di un'app denominata word_readere si pubblica un eseguibile autonomo per Windows, viene creato un file word_reader.exe.For example, if you have an app named word_reader, and you publish a self-contained executable for Windows, a word_reader.exe file is created. Pubblicazione per Linux o macOS, viene creato un file word_reader.Publishing for Linux or macOS, a word_reader file is created. La piattaforma e l'architettura -r <RID> di dotnet publish destinazione vengono specificate con il parametro per il comando.The target platform and architecture is specified with the -r <RID> parameter for the dotnet publish command. Per ulteriori informazioni sui RID, vedere .NET Core RID Catalog.For more information about RIDs, see .NET Core RID Catalog.

Se l'app ha dipendenze specifiche della piattaforma, ad esempio un pacchetto NuGet contenente dipendenze specifiche della piattaforma, queste vengono copiate nella cartella di pubblicazione insieme all'app.If the app has platform-specific dependencies, such as a NuGet package containing platform-specific dependencies, these are copied to the publish folder along with the app.

VantaggiAdvantages

  • Controllare la versione di .NET CoreControl .NET Core version
    È possibile controllare quale versione di .NET Core viene distribuita con l'app.You control which version of .NET Core is deployed with your app.

  • Targeting specifico della piattaformaPlatform-specific targeting
    Poiché devi pubblicare l'app per ogni piattaforma, sai dove verrà eseguita l'app.Because you have to publish your app for each platform, you know where your app will run. Se .NET Core introduce una nuova piattaforma, gli utenti non possono eseguire l'app su tale piattaforma finché non si rilascia una versione destinata a tale piattaforma.If .NET Core introduces a new platform, users can't run your app on that platform until you release a version targeting that platform. Puoi testare la compatibilità dell'app prima che gli utenti esedano l'app nella nuova piattaforma.You can test your app for compatibility problems before your users run your app on the new platform.

SvantaggiDisadvantages

  • Distribuzioni più grandiLarger deployments
    Poiché l'app include il runtime di .NET Core e tutte le dipendenze dell'app, le dimensioni del download e lo spazio sul disco rigido necessari sono maggiori di una versione dipendente dal runtime.Because your app includes the .NET Core runtime and all of your app dependencies, the download size and hard drive space required is greater than a runtime-dependent version.

    Suggerimento

    È possibile ridurre le dimensioni della distribuzione nei sistemi Linux di circa 28 MB utilizzando la modalità invariantedi globalizzazione di .NET Core .You can reduce the size of your deployment on Linux systems by approximately 28 MB by using .NET Core globalization invariant mode. In questo modo l'app deve gestire tutte le impostazioni cultura, ad esempio le impostazioni cultura invarianti.This forces your app to treat all cultures like the invariant culture.

  • Più difficile aggiornare la versione di .NET CoreHarder to update the .NET Core version
    .NET Core Runtime (distribuito con l'app) può essere aggiornato solo rilasciando una nuova versione dell'app..NET Core Runtime (distributed with your app) can only be upgraded by releasing a new version of your app. L'utente è responsabile della fornitura di una versione aggiornata dell'applicazione per le patch di sicurezza per il runtime di .NET Core.You're responsible for supplying an updated version of your application for security patches to the .NET Core Runtime.

EsempiExamples

Pubblicare un'app indipendente.Publish an app self-contained. Viene creato un eseguibile a 64 bit di macOS.A macOS 64-bit executable is created.

dotnet publish -r osx-x64

Pubblicare un'app indipendente.Publish an app self-contained. Viene creato un eseguibile di Windows a 64 bit.A Windows 64-bit executable is created.

dotnet publish -r win-x64

Vedere ancheSee also