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

Le applicazioni create con .NET Core possono essere pubblicate in due modalità diverse e la modalità influiscono 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 di .NET Core e 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 eseguirla 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 produce un'applicazione che include solo l'applicazione stessa e le relative dipendenze.Publishing your app as runtime-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.

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

Quando viene prodotto un file 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 su rid, vedere il Catalogo dei RID di .NET Core.For more information about RIDs, see .NET Core RID Catalog.

La tabella seguente descrive i comandi usati per pubblicare un'app come dipendente dal runtime o autonomo, per versione SDK: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
eseguibile indipendente.self-contained executable. ✔️✔️ ✔️✔️ dotnet publish -r <RID>

Per altre informazioni, vedere comando DotNet Publish 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 di un'architettura della CPU.They're specific to an operating system and CPU architecture. Quando si pubblica l'app e si crea un eseguibile, è possibile pubblicare l'app come dipendente autonomo o di 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 indipendente 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 l'app e le dipendenze 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 comandi seguenti 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
eseguibile indipendente.self-contained executable. ✔️✔️ ✔️✔️ dotnet publish -r <RID>

Produrre un file 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 nome del file dll viene eseguito dopo il progetto.The dll file is named after your project. Se, ad esempio, 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 questo modo vengono eseguite con il comando dotnet <filename.dll> 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 in qualsiasi sistema operativo, purché il runtime di .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 di .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, vedere rollforward delle app dipendenti dal runtime.For more information, see runtime-dependent apps roll forward.

Il comando seguente genera un file binario multipiattaforma: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

Pubblicazione dipendente dal runtimePublish runtime-dependent

Le app pubblicate come dipendenti dal runtime sono multipiattaforma e non includono il runtime di .NET Core.Apps published as runtime-dependent are cross-platform and don't include the .NET Core runtime. L'utente dell'app è necessario per 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 file 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. Se ad esempio si pubblica un'app denominata word_reader e Windows di destinazione, viene creato un file 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 la destinazione è Linux o macOS, viene creato un file 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 su rid, vedere il Catalogo dei RID di .NET Core.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 può essere eseguito con il comando dotnet <filename.dll> 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 una piattaforma specifica passando i parametri -r <RID> --self-contained false al comando dotnet publish .You can create an executable for a specific platform by passing the -r <RID> --self-contained false parameters to the dotnet publish command. Quando il parametro -r 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

  • \ di distribuzione di piccole dimensioniSmall deployment</span> Verranno distribuite 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</span> L'app e qualsiasi. La libreria basata su rete viene eseguita in 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 di file di assembly .NET.For information about the .NET file format, see .NET Assembly File Format.

  • Usa l'ultimo runtime con patchUses the latest patched runtime
    L'app usa il runtime più recente (all'interno della famiglia principale-secondaria 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 più recente con patch 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, vedere rollforward delle app dipendenti dal runtime.For more information, see runtime-dependent apps roll forward.

SvantaggiDisadvantages

  • Richiede la pre-installazione 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 in modo che sia necessaria 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. Per altre informazioni, vedere rollforward delle app dipendenti dal runtime.For more information, see runtime-dependent apps roll forward.

  • .NET Core può cambiare.NET Core may change
    È possibile che le librerie e il runtime di .NET Core 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, questo potrebbe modificare il comportamento dell'app se si usano le librerie .NET Core, che la 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. È possibile 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. Per altre informazioni, vedere rollforward delle app dipendenti dal runtime.For more information, see runtime-dependent apps roll forward.

Gli svantaggi seguenti si applicano solo a .NET Core 2,1 SDK.The following disadvantage only applies to .NET Core 2.1 SDK.

  • Usare il comando dotnet per avviare l'appUse the dotnet command to start the app
    Per avviare l'app, gli utenti devono eseguire il comando dotnet <filename.dll>.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 che dipendono 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. Un eseguibile destinato alla piattaforma corrente viene creato 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. Insieme al file dll viene creato un eseguibile Linux a 64 bit.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

Pubblicazione indipendentePublish self-contained

La pubblicazione dell'app come indipendente produce un eseguibile specifico della piattaforma.Publishing your app as self-contained produces a platform-specific executable. La cartella di pubblicazione di 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 dalle 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. Se, ad esempio, 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 di word_reader .Publishing for Linux or macOS, a word_reader file is created. La piattaforma e l'architettura di destinazione vengono specificate con il parametro -r <RID> per il comando dotnet publish .The target platform and architecture is specified with the -r <RID> parameter for the dotnet publish command. Per ulteriori informazioni su rid, vedere il Catalogo dei RID di .NET Core.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 publish 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 la versione di .NET Core distribuita con l'app.You control which version of .NET Core is deployed with your app.

  • \ di destinazione specifici della piattaformaPlatform-specific targeting</span> Poiché è necessario pubblicare l'app per ogni piattaforma, si sa dove viene 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 viene rilasciata una versione destinata alla 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. È possibile testare l'app per i problemi di compatibilità prima che gli utenti eseguano 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 di dimensioni maggioriLarger deployments
    Poiché l'app include il runtime di .NET Core e tutte le dipendenze dell'app, le dimensioni del download e lo spazio su disco rigido richiesto 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 usando la modalità invariante di globalizzazionedi .NET Core.You can reduce the size of your deployment on Linux systems by approximately 28 MB by using .NET Core globalization invariant mode. Questa operazione impone all'app di trattare tutte le impostazioni cultura come la lingua inglese.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
    Il runtime di .NET Core (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. Si è responsabili della fornitura di una versione aggiornata dell'applicazione per le patch di sicurezza al 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 file eseguibile macOS a 64 bit.A macOS 64-bit executable is created.

dotnet publish -r osx-x64

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

dotnet publish -r win-x64

Vedere ancheSee also