Distribuera .NET Core-appar med Visual Studio

Du kan distribuera ett .NET Core-program antingen som en ramverksberoende distribution, som innehåller dina programbinärfiler men som är beroende av förekomsten av .NET Core i målsystemet eller som en fristående distribution, som innehåller både dina program- och .NET Core-binärfiler. En översikt över distributionen av .NET Core-program finns i .NET Core-programdistribution.

Följande avsnitt visar hur du använder Microsoft Visual Studio för att skapa följande typer av distributioner:

• Ramverksberoende distribution
• Ramverksberoende distribution med tredjepartsberoenden
• Fristående distribution
• Fristående distribution med beroenden från tredje part

Information om hur du använder Visual Studio för att utveckla .NET Core-program finns i .NET Core-beroenden och krav.

Ramverksberoende distribution

Att distribuera en ramverksberoende distribution utan beroenden från tredje part innebär helt enkelt att skapa, testa och publicera appen. Ett enkelt exempel skrivet i C# illustrerar processen.

1. Skapa projektet.

   Välj Arkiv>Nytt>Projekt. I dialogrutan Nytt projekt expanderar du språkprojektkategorierna (C# eller Visual Basic) i fönstret Installerade projekttyper, väljer .NET Core och väljer sedan mallen Konsolapp (.NET Core) i mittenfönstret. Ange ett projektnamn, till exempel "FDD", i textrutan Namn . Välj knappen OK.

2. Lägg till programmets källkod.

   Öppna filen Program.cs eller Program.vb i redigeraren och ersätt den automatiskt genererade koden med följande kod. Användaren uppmanas att ange text och visa de enskilda ord som användaren har angett. Det använder det reguljära uttrycket \w+ för att avgränsa orden i indatatexten.

   using System;
   using System.Text.RegularExpressions;
   
   namespace Applications.ConsoleApps
   {
       public class ConsoleParser
       {
           public static void Main()
           {
               Console.WriteLine("Enter any text, followed by <Enter>:\n");
               String? s = Console.ReadLine();
               ShowWords(s ?? "You didn't enter anything.");
               Console.Write("\nPress any key to continue... ");
               Console.ReadKey();
           }
   
           private static void ShowWords(String s)
           {
               String pattern = @"\w+";
               var matches = Regex.Matches(s, pattern);
               if (matches.Count == 0)
               {
                   Console.WriteLine("\nNo words were identified in your input.");
               }
               else
               {
                   Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                   for (int ctr = 0; ctr < matches.Count; ctr++)
                   {
                       Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                   }
               }
           }
       }
   }
   

   Imports System.Text.RegularExpressions
   
   Namespace Applications.ConsoleApps
       Public Module ConsoleParser
           Public Sub Main()
               Console.WriteLine("Enter any text, followed by <Enter>:")
               Console.WriteLine()
               Dim s = Console.ReadLine()
               ShowWords(s)
               Console.Write($"{vbCrLf}Press any key to continue... ")
               Console.ReadKey()
           End Sub
   
           Private Sub ShowWords(s As String)
               Dim pattern = "\w+"
               Dim matches = Regex.Matches(s, pattern)
               Console.WriteLine()   
               If matches.Count = 0 Then
                   Console.WriteLine("No words were identified in your input.")
               Else
                   Console.WriteLine($"There are {matches.Count} words in your string:")
                   For ctr = 0 To matches.Count - 1
                       Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                   Next
               End If
               Console.WriteLine()
           End Sub
       End Module
   End Namespace
   
   

3. Skapa en felsökningsversion av din app.

   Välj Skapa>bygglösning. Du kan också kompilera och köra felsökningsversionen av ditt program genom att välja Felsöka >Starta felsökning.

4. Distribuera din app.

   När du har debuggat och testat programmet skapar du de filer som ska distribueras med din app. Gör följande för att publicera från Visual Studio:

   1. Ändra lösningskonfigurationen från Felsökning till Släpp i verktygsfältet för att skapa en Version (i stället för en felsökningsversion) av din app.

   2. Högerklicka på projektet (inte lösningen) i Solution Explorer och välj Publicera.

   3. På fliken Publicera väljer du Publicera. Visual Studio skriver de filer som utgör ditt program till det lokala filsystemet.

   4. Fliken Publicera visar nu en enda profil, FolderProfile. Profilens konfigurationsinställningar visas i avsnittet Sammanfattning på fliken.

   De resulterande filerna placeras i en katalog med namnet Publish i Windows och publish på Unix-system som finns i en underkatalog till projektets underkatalog .\bin\release\netcoreapp2.1 .

Tillsammans med programmets filer genererar publiceringsprocessen en programdatabasfil (.pdb) som innehåller felsökningsinformation om din app. Filen är användbar främst för felsökning av undantag. Du kan välja att inte paketera det med programmets filer. Du bör dock spara den om du vill felsöka versionen av din app.

Distribuera hela uppsättningen programfiler på det sätt du vill. Du kan till exempel paketera dem i en Zip-fil, använda ett enkelt copy kommando eller distribuera dem med valfritt installationspaket. När programmet har installerats kan användarna sedan köra programmet med hjälp dotnet av kommandot och ange programmets filnamn, till exempel dotnet fdd.dll.

Förutom programbinärfilerna bör installationsprogrammet antingen paketera installationsprogrammet för delat ramverk eller söka efter det som en förutsättning som en del av programinstallationen. Installationen av det delade ramverket kräver administratörs-/rotåtkomst eftersom det är datoromfattande.

Ramverksberoende distribution med tredjepartsberoenden

Distribution av en ramverksberoende distribution med ett eller flera beroenden från tredje part kräver att eventuella beroenden är tillgängliga för projektet. Följande ytterligare steg krävs innan du kan skapa din app:

1. Använd NuGet Package Manager för att lägga till en referens till ett NuGet-paket i projektet. Installera det om paketet inte redan är tillgängligt i systemet. Öppna pakethanteraren genom att välja Verktyg>NuGet Package Manager>Hantera NuGet-paket för lösning.

2. Bekräfta att dina beroenden från tredje part (till exempel Newtonsoft.Json) är installerade i systemet och installera dem om de inte är det. Fliken Installerad visar NuGet-paket som är installerade i systemet. Om Newtonsoft.Json inte visas där väljer du fliken Bläddra och anger "Newtonsoft.Json" i sökrutan. Välj Newtonsoft.Json och välj projektet i den högra rutan innan du väljer Installera.

3. Om Newtonsoft.Json det redan är installerat på systemet lägger du till det i projektet genom att välja projektet i den högra rutan på fliken Hantera paket för lösning .

En ramverksberoende distribution med tredjepartsberoenden är bara lika portabel som dess beroenden från tredje part. Om ett bibliotek från tredje part till exempel bara stöder macOS är appen inte portabel för Windows-system. Detta inträffar om själva beroendet från tredje part är beroende av intern kod. Ett bra exempel på detta är Kestrel-servern, som kräver ett internt beroende av libuv. När en FDD skapas för ett program med den här typen av beroende från tredje part innehåller de publicerade utdata en mapp för varje Runtime Identifier (RID) som det interna beroendet stöder (och som finns i dess NuGet-paket).

Fristående distribution utan beroenden från tredje part

Att distribuera en fristående distribution utan beroenden från tredje part innebär att skapa projektet, ändra csproj-filen , skapa, testa och publicera appen. Ett enkelt exempel skrivet i C# illustrerar processen. Du börjar med att skapa, koda och testa projektet på samma sätt som en ramverksberoende distribution:

1. Skapa projektet.

   Välj Arkiv>Nytt>Projekt. I dialogrutan Nytt projekt expanderar du språkprojektkategorierna (C# eller Visual Basic) i fönstret Installerade projekttyper, väljer .NET Core och väljer sedan mallen Konsolapp (.NET Core) i mittenfönstret. Ange ett projektnamn, till exempel "SCD", i textrutan Namn och välj knappen OK .

2. Lägg till programmets källkod.

   Öppna filen Program.cs eller Program.vb i redigeringsprogrammet och ersätt den automatiskt genererade koden med följande kod. Användaren uppmanas att ange text och visa de enskilda ord som användaren har angett. Det använder det reguljära uttrycket \w+ för att avgränsa orden i indatatexten.

   using System;
   using System.Text.RegularExpressions;
   
   namespace Applications.ConsoleApps
   {
       public class ConsoleParser
       {
           public static void Main()
           {
               Console.WriteLine("Enter any text, followed by <Enter>:\n");
               String? s = Console.ReadLine();
               ShowWords(s ?? "You didn't enter anything.");
               Console.Write("\nPress any key to continue... ");
               Console.ReadKey();
           }
   
           private static void ShowWords(String s)
           {
               String pattern = @"\w+";
               var matches = Regex.Matches(s, pattern);
               if (matches.Count == 0)
               {
                   Console.WriteLine("\nNo words were identified in your input.");
               }
               else
               {
                   Console.WriteLine($"\nThere are {matches.Count} words in your string:");
                   for (int ctr = 0; ctr < matches.Count; ctr++)
                   {
                       Console.WriteLine($"   #{ctr,2}: '{matches[ctr].Value}' at position {matches[ctr].Index}");
                   }
               }
           }
       }
   }
   

   Imports System.Text.RegularExpressions
   
   Namespace Applications.ConsoleApps
       Public Module ConsoleParser
           Public Sub Main()
               Console.WriteLine("Enter any text, followed by <Enter>:")
               Console.WriteLine()
               Dim s = Console.ReadLine()
               ShowWords(s)
               Console.Write($"{vbCrLf}Press any key to continue... ")
               Console.ReadKey()
           End Sub
   
           Private Sub ShowWords(s As String)
               Dim pattern = "\w+"
               Dim matches = Regex.Matches(s, pattern)
               Console.WriteLine()   
               If matches.Count = 0 Then
                   Console.WriteLine("No words were identified in your input.")
               Else
                   Console.WriteLine($"There are {matches.Count} words in your string:")
                   For ctr = 0 To matches.Count - 1
                       Console.WriteLine($"   #{ctr,2}: '{matches(ctr).Value}' at position {matches(ctr).Index}")
                   Next
               End If
               Console.WriteLine()
           End Sub
       End Module
   End Namespace
   
   

3. Ta reda på om du vill använda globalisering ivariant läge.

   Särskilt om din app riktar sig mot Linux kan du minska den totala storleken på distributionen genom att dra nytta av globalisering i variant läge. Globaliseringsläge är användbart för program som inte är globalt medvetna och som kan använda formateringskonventioner, höljekonventioner och strängjämförelse och sorteringsordning för den invarianta kulturen.

   Om du vill aktivera invariant läge högerklickar du på projektet (inte lösningen) i Solution Explorer och väljer Redigera SCD.csproj eller Redigera SCD.vbproj. Lägg sedan till följande markerade rader i filen:

   <Project Sdk="Microsoft.NET.Sdk">
   
     <PropertyGroup>
       <TargetFramework>net6.0</TargetFramework>
       <Nullable>enable</Nullable>
     </PropertyGroup>
   
     <ItemGroup>
       <RuntimeHostConfigurationOption Include="System.Globalization.Invariant" Value="true" />
     </ItemGroup> 
   
   </Project>
   

4. Skapa en felsökningsversion av ditt program.

   Välj Skapa>bygglösning. Du kan också kompilera och köra felsökningsversionen av ditt program genom att välja Felsöka >Starta felsökning. Med det här felsökningssteget kan du identifiera problem med ditt program när det körs på värdplattformen. Du måste fortfarande testa det på var och en av dina målplattformar.

   Om du har aktiverat globalisering ivariant läge bör du testa om frånvaron av kulturkänsliga data är lämplig för ditt program.

När du är klar med felsökningen kan du publicera din fristående distribution:

Visual Studio 15.6 och tidigare

När du har debuggat och testat programmet skapar du de filer som ska distribueras med din app för varje plattform som den riktar in sig på.

Gör följande för att publicera din app från Visual Studio:

1. Definiera de plattformar som din app ska rikta in sig på.

   1. Högerklicka på projektet (inte lösningen) i Solution Explorer och välj Redigera SCD.csproj.

   2. Skapa en <RuntimeIdentifiers> tagg i avsnittet i <PropertyGroup> csproj-filensom definierar de plattformar som appen riktar in sig på och ange körningsidentifieraren (RID) för varje plattform som du riktar in dig på. Du måste också lägga till ett semikolon för att separera RID:erna. En lista över körningsidentifierare finns i Katalogen för Körningsidentifierare .

   Följande exempel anger till exempel att appen körs på 64-bitars Windows-operativsystem och 64-bitars OS X-operativsystemet.

   <PropertyGroup>
      <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
   </PropertyGroup>
   

   Elementet <RuntimeIdentifiers> kan gå till alla <PropertyGroup> som du har i csproj-filen. En fullständig csproj-exempelfil visas senare i det här avsnittet.

2. Publicera din app.

   När du har debuggat och testat programmet skapar du de filer som ska distribueras med din app för varje plattform som den riktar in sig på.

   Gör följande för att publicera din app från Visual Studio:

   1. Ändra lösningskonfigurationen från Felsökning till Släpp i verktygsfältet för att skapa en Version (i stället för en felsökningsversion) av din app.

   2. Högerklicka på projektet (inte lösningen) i Solution Explorer och välj Publicera.

   3. På fliken Publicera väljer du Publicera. Visual Studio skriver de filer som utgör ditt program till det lokala filsystemet.

   4. Fliken Publicera visar nu en enda profil, FolderProfile. Profilens konfigurationsinställningar visas i avsnittet Sammanfattning på fliken. Målkörning identifierar vilken körning som har publicerats och Målplats identifierar var filerna för den fristående distributionen skrevs.

   5. Visual Studio skriver som standard alla publicerade filer till en enda katalog. För enkelhetens skull är det bäst att skapa separata profiler för varje målkörning och placera publicerade filer i en plattformsspecifik katalog. Detta innebär att skapa en separat publiceringsprofil för varje målplattform. Återskapa därför programmet för varje plattform genom att göra följande:

      1. Välj Skapa ny profil i dialogrutan Publicera .

      2. I dialogrutan Välj ett publiceringsmål ändrar du platsen Välj en mapp till bin\Release\PublishOutput\win-x64. Välj OK.

      3. Välj den nya profilen (FolderProfile1) i listan med profiler och kontrollera att Målkörningen är win-x64. Om det inte är det väljer du Inställningar. I dialogrutan Profil Inställningar ändrar du Målkörning till win-x64 och väljer Spara. Annars väljer du Avbryt.

      4. Välj Publicera för att publicera din app för 64-bitars Windows 10-plattformar.

      5. Följ föregående steg igen för att skapa en profil för osx-x64 plattformen. Målplatsen är bin\Release\PublishOutput\osx-x64 och Målkörningen är osx-x64. Namnet som Visual Studio tilldelar den här profilen är FolderProfile2.

   Varje målplats innehåller den fullständiga uppsättningen filer (både dina appfiler och alla .NET Core-filer) som behövs för att starta appen.

Tillsammans med programmets filer genererar publiceringsprocessen en programdatabasfil (.pdb) som innehåller felsökningsinformation om din app. Filen är användbar främst för felsökning av undantag. Du kan välja att inte paketera det med programmets filer. Du bör dock spara den om du vill felsöka versionen av din app.

Distribuera de publicerade filerna på valfritt sätt. Du kan till exempel paketera dem i en Zip-fil, använda ett enkelt copy kommando eller distribuera dem med valfritt installationspaket.

Följande är den fullständiga csproj-filen för det här projektet.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
  </PropertyGroup>
</Project>

Visual Studio 15.7 och senare

När du har debuggat och testat programmet skapar du de filer som ska distribueras med din app för varje plattform som den riktar in sig på. Detta innebär att skapa en separat profil för varje målplattform.

Gör följande för varje plattform som ditt program riktar in sig på:

1. Skapa en profil för målplattformen.

   Om det här är den första profilen som du har skapat högerklickar du på projektet (inte lösningen) i Solution Explorer och väljer Publicera.

   Om du redan har skapat en profil högerklickar du på projektet för att öppna dialogrutan Publicera om den inte redan är öppen. Välj sedan Ny profil.

   Dialogrutan Välj ett publiceringsmål öppnas.

2. Välj den plats där Visual Studio publicerar ditt program.

   Om du bara publicerar till en enda plattform kan du acceptera standardvärdet i textrutan Välj en mapp . Detta publicerar den ramverksberoende distributionen av ditt program till <katalogen project-directory>\bin\Release\netcoreapp2.1\publish .

   Om du publicerar till mer än en plattform lägger du till en sträng som identifierar målplattformen. Om du till exempel lägger till strängen "linux" i filsökvägen publicerar Visual Studio den ramverksberoende distributionen av ditt program till <katalogen project-directory>\bin\Release\netcoreapp2.1\publish\linux .

3. Skapa profilen genom att välja listrutan bredvid knappen Publicera och välja Skapa profil. Välj sedan knappen Skapa profil för att skapa profilen.

4. Ange att du publicerar en fristående distribution och definierar en plattform som din app ska rikta in sig på.

   1. I dialogrutan Publicera väljer du länken Konfigurera för att öppna dialogrutan Profil Inställningar.

   2. Välj Fristående i listrutan Distributionsläge .

   3. I listrutan Målkörning väljer du en av de plattformar som programmet riktar in sig på.

   4. Välj Spara för att acceptera ändringarna och stäng dialogrutan.

5. Namnge din profil.

   1. Välj Åtgärder>Byt namn på profil för att namnge din profil.

   2. Tilldela din profil ett namn som identifierar målplattformen och välj sedan *Spara.

Upprepa de här stegen för att definiera eventuella ytterligare målplattformar som programmet riktar in sig på.

Du har konfigurerat dina profiler och är nu redo att publicera din app. Så här gör du:

1. Om publiceringsfönstret inte är öppet för tillfället högerklickar du på projektet (inte lösningen) i Solution Explorer och väljer Publicera.

2. Välj den profil som du vill publicera och välj sedan Publicera. Gör detta för varje profil som ska publiceras.

Varje målplats (i vårt exempel bin\release\netcoreapp2.1\publish\profile-name) innehåller den fullständiga uppsättning filer (både dina appfiler och alla .NET Core-filer) som behövs för att starta appen.

Tillsammans med programmets filer genererar publiceringsprocessen en programdatabasfil (.pdb) som innehåller felsökningsinformation om din app. Filen är användbar främst för felsökning av undantag. Du kan välja att inte paketera det med programmets filer. Du bör dock spara den om du vill felsöka versionen av din app.

Distribuera de publicerade filerna på valfritt sätt. Du kan till exempel paketera dem i en Zip-fil, använda ett enkelt copy kommando eller distribuera dem med valfritt installationspaket.

Följande är den fullständiga csproj-filen för det här projektet.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
</Project>

Dessutom skapar Visual Studio en separat publiceringsprofil (*.pubxml) för varje plattform som du riktar in dig på. Filen för vår Linux-profil (linux.pubxml) visas till exempel på följande sätt:

<?xml version="1.0" encoding="utf-8"?>
<!--
https://go.microsoft.com/fwlink/?LinkID=208121.
-->
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <PublishProtocol>FileSystem</PublishProtocol>
    <Configuration>Release</Configuration>
    <Platform>Any CPU</Platform>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <PublishDir>bin\Release\netcoreapp2.1\publish\linux</PublishDir>
    <RuntimeIdentifier>win-x86</RuntimeIdentifier>
    <SelfContained>true</SelfContained>
    <_IsPortable>false</_IsPortable>
  </PropertyGroup>
</Project>

Fristående distribution med beroenden från tredje part

Att distribuera en fristående distribution med ett eller flera beroenden från tredje part innebär att du lägger till beroendena. Följande ytterligare steg krävs innan du kan skapa din app:

1. Använd NuGet Package Manager för att lägga till en referens till ett NuGet-paket i projektet. Installera det om paketet inte redan är tillgängligt i systemet. Öppna pakethanteraren genom att välja Verktyg>NuGet Package Manager>Hantera NuGet-paket för lösning.

2. Bekräfta att dina beroenden från tredje part (till exempel Newtonsoft.Json) är installerade i systemet och installera dem om de inte är det. Fliken Installerad visar NuGet-paket som är installerade i systemet. Om Newtonsoft.Json inte visas där väljer du fliken Bläddra och anger "Newtonsoft.Json" i sökrutan. Välj Newtonsoft.Json och välj projektet i den högra rutan innan du väljer Installera.

3. Om Newtonsoft.Json det redan är installerat på systemet lägger du till det i projektet genom att välja projektet i den högra rutan på fliken Hantera paket för lösning .

Följande är den fullständiga csproj-filen för det här projektet:

Visual Studio 15.6 och tidigare

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
    <RuntimeIdentifiers>win-x64;osx-x64</RuntimeIdentifiers>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

Visual Studio 15.7 och senare

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp2.1</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
  </ItemGroup>
</Project>

När du distribuerar ditt program finns även eventuella beroenden från tredje part som används i din app med dina programfiler. Bibliotek från tredje part krävs inte i systemet där appen körs.

Du kan bara distribuera en fristående distribution med ett bibliotek från tredje part till plattformar som stöds av biblioteket. Detta liknar att ha beroenden från tredje part med inbyggda beroenden i din ramverksberoende distribution, där de interna beroendena inte finns på målplattformen om de inte tidigare har installerats där.

Se även

• Distribution av .NET Core-program
• RID-katalog (.NET Core Runtime Identifier)