.NET Core-apps implementeren met Visual Studio

U kunt een .NET Core-toepassing implementeren als een frameworkafhankelijke implementatie, die binaire toepassingsbestanden bevat, maar afhankelijk is van de aanwezigheid van .NET Core op het doelsysteem, of als een zelfstandige implementatie, die zowel uw toepassing als binaire .NET Core-bestanden bevat. Zie .NET Core-toepassingsimplementatie voor een overzicht van .NET Core-toepassingsimplementatie.

In de volgende secties ziet u hoe u Microsoft Visual Studio gebruikt om de volgende soorten implementaties te maken:

• Frameworkafhankelijke implementatie
• Frameworkafhankelijke implementatie met afhankelijkheden van derden
• Zelfstandige implementatie
• Zelfstandige implementatie met afhankelijkheden van derden

Zie .NET Core-afhankelijkheden en -vereisten voor informatie over het gebruik van Visual Studio voor het ontwikkelen van .NET Core-toepassingen.

Frameworkafhankelijke implementatie

Het implementeren van een frameworkafhankelijke implementatie zonder afhankelijkheden van derden omvat het bouwen, testen en publiceren van de app. Een eenvoudig voorbeeld dat is geschreven in C# illustreert het proces.

1. Maak het project.

   Selecteer Bestand>Nieuw>Project. Vouw in het dialoogvenster Nieuw project de projectcategorieën (C# of Visual Basic) van uw taal uit in het deelvenster Geïnstalleerde projecttypen, kies .NET Core en selecteer vervolgens de sjabloon Console-app (.NET Core) in het middelste deelvenster. Voer een projectnaam in, zoals 'FDD', in het tekstvak Naam . Selecteer de knop OK.

2. Voeg de broncode van de toepassing toe.

   Open het bestand Program.cs of Program.vb in de editor en vervang de automatisch gegenereerde code door de volgende code. De gebruiker wordt gevraagd tekst in te voeren en de afzonderlijke woorden weer te geven die door de gebruiker zijn ingevoerd. De reguliere expressie \w+ wordt gebruikt om de woorden in de invoertekst te scheiden.

   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. Maak een foutopsporingsbuild van uw app.

   Selecteer Bouwen>Oplossing bouwen. U kunt ook de build voor foutopsporing van uw toepassing compileren en uitvoeren door Foutopsporing> starten te selecteren.

4. Implementeer uw app.

   Nadat u fouten hebt opgespoord en getest, maakt u de bestanden die moeten worden geïmplementeerd met uw app. Ga als volgt te werk om vanuit Visual Studio te publiceren:

   1. Wijzig de oplossingsconfiguratie van Foutopsporing in Release op de werkbalk om een releaseversie (in plaats van een foutopsporing) versie van uw app te bouwen.

   2. Klik met de rechtermuisknop op het project (niet de oplossing) in Solution Explorer en selecteer Publiceren.

   3. Selecteer Publiceren op het tabblad Publiceren. Visual Studio schrijft de bestanden die uit uw toepassing bestaan naar het lokale bestandssysteem.

   4. Het tabblad Publiceren toont nu één profiel, FolderProfile. De configuratie-instellingen van het profiel worden weergegeven in de sectie Samenvatting van het tabblad.

   De resulterende bestanden worden in een map met de naam Publish Windows en publish op Unix-systemen geplaatst in een submap van de submap .\bin\release\netcoreapp2.1 van uw project.

Samen met de bestanden van uw toepassing verzendt het publicatieproces een programmadatabasebestand (.pdb) dat foutopsporingsinformatie over uw app bevat. Het bestand is vooral handig voor het opsporen van fouten in uitzonderingen. U kunt ervoor kiezen deze niet te verpakken met de bestanden van uw toepassing. U moet deze echter opslaan in het geval dat u fouten wilt opsporen in de release-build van uw app.

Implementeer de volledige set toepassingsbestanden op elke gewenste manier. U kunt ze bijvoorbeeld inpakken in een Zip-bestand, een eenvoudige copy opdracht gebruiken of ze implementeren met elk installatiepakket van uw keuze. Zodra de toepassing is geïnstalleerd, kunnen gebruikers uw toepassing uitvoeren met behulp van de dotnet opdracht en de bestandsnaam van de toepassing opgegeven, zoals dotnet fdd.dll.

Naast de binaire bestanden van de toepassing moet uw installatieprogramma ook het installatieprogramma voor het gedeelde framework bundelen of controleren als een vereiste als onderdeel van de installatie van de toepassing. Voor de installatie van het gedeelde framework is Beheer istrator-/hoofdtoegang vereist, omdat dit computerbreed is.

Frameworkafhankelijke implementatie met afhankelijkheden van derden

Voor het implementeren van een frameworkafhankelijke implementatie met een of meer afhankelijkheden van derden is vereist dat afhankelijkheden beschikbaar zijn voor uw project. De volgende extra stappen zijn vereist voordat u uw app kunt bouwen:

1. Gebruik de NuGet-Pakketbeheer om een verwijzing naar een NuGet-pakket toe te voegen aan uw project. Als het pakket nog niet beschikbaar is op uw systeem, installeert u het. Als u pakketbeheer wilt openen, selecteert u Tools>NuGet Pakketbeheer> Manage NuGet-pakketten voor oplossing.

2. Controleer of uw afhankelijkheden van derden (bijvoorbeeld Newtonsoft.Json) op uw systeem zijn geïnstalleerd en, als dat niet het is, installeert u deze. Op het tabblad Geïnstalleerd worden NuGet-pakketten weergegeven die op uw systeem zijn geïnstalleerd. Als Newtonsoft.Json hier niet wordt vermeld, selecteert u het tabblad Bladeren en voert u Newtonsoft.Json in het zoekvak in. Selecteer Newtonsoft.Json en selecteer uw project in het rechterdeelvenster voordat u Installeren selecteert.

3. Als Newtonsoft.Json het systeem al is geïnstalleerd, voegt u het toe aan uw project door uw project te selecteren in het rechterdeelvenster van het tabblad Pakketten voor oplossing beheren.

Een frameworkafhankelijke implementatie met afhankelijkheden van derden is alleen net zo draagbaar als de afhankelijkheden van derden. Als een bibliotheek van derden bijvoorbeeld alleen macOS ondersteunt, is de app niet overdraagbaar naar Windows-systemen. Dit gebeurt als de afhankelijkheid van derden zelf afhankelijk is van systeemeigen code. Een goed voorbeeld hiervan is Kestrel-server, waarvoor een systeemeigen afhankelijkheid van libuv is vereist. Wanneer een FDD wordt gemaakt voor een toepassing met dit soort afhankelijkheid van derden, bevat de gepubliceerde uitvoer een map voor elke runtime-id (RID) die door de systeemeigen afhankelijkheid wordt ondersteund (en die bestaat in het NuGet-pakket).

Zelfstandige implementatie zonder afhankelijkheden van derden

Het implementeren van een zelfstandige implementatie zonder afhankelijkheden van derden omvat het maken van het project, het wijzigen van het csproj-bestand, het bouwen, testen en publiceren van de app. Een eenvoudig voorbeeld dat is geschreven in C# illustreert het proces. U begint met het maken, coderen en testen van uw project, net zoals bij een frameworkafhankelijke implementatie:

1. Maak het project.

   Selecteer Bestand>Nieuw>Project. Vouw in het dialoogvenster Nieuw project de projectcategorieën (C# of Visual Basic) van uw taal uit in het deelvenster Geïnstalleerde projecttypen, kies .NET Core en selecteer vervolgens de sjabloon Console-app (.NET Core) in het middelste deelvenster. Voer een projectnaam, zoals SCD, in het tekstvak Naam in en selecteer de knop OK .

2. Voeg de broncode van de toepassing toe.

   Open het bestand Program.cs of Program.vb in de editor en vervang de automatisch gegenereerde code door de volgende code. De gebruiker wordt gevraagd tekst in te voeren en de afzonderlijke woorden weer te geven die door de gebruiker zijn ingevoerd. De reguliere expressie \w+ wordt gebruikt om de woorden in de invoertekst te scheiden.

   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. Bepaal of u de invariante modus voor globalisatie wilt gebruiken.

   Met name als uw app is gericht op Linux, kunt u de totale grootte van uw implementatie verminderen door te profiteren van de invariant-modus voor globalisatie. Globalisatie invariantmodus is handig voor toepassingen die niet globaal op de hoogte zijn en die de opmaakconventies, casingconventies en tekenreeksvergelijking en sorteervolgorde van de invariante cultuur kunnen gebruiken.

   Als u de invariantmodus wilt inschakelen, klikt u met de rechtermuisknop op uw project (niet de oplossing) in Solution Explorer en selecteert u SCD.csproj bewerken of SCD.vbproj bewerken. Voeg vervolgens de volgende gemarkeerde regels toe aan het bestand:

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

4. Maak een foutopsporingsbuild van uw toepassing.

   Selecteer Bouwen>Oplossing bouwen. U kunt ook de build voor foutopsporing van uw toepassing compileren en uitvoeren door Foutopsporing> starten te selecteren. Met deze foutopsporingsstap kunt u problemen met uw toepassing identificeren wanneer deze wordt uitgevoerd op uw hostplatform. U moet het nog steeds testen op elk van uw doelplatforms.

   Als u de invariante modus voor globalisatie hebt ingeschakeld, moet u met name testen of het ontbreken van cultuurgevoelige gegevens geschikt is voor uw toepassing.

Zodra u klaar bent met foutopsporing, kunt u uw zelfstandige implementatie publiceren:

Visual Studio 15.6 en eerder

Nadat u fouten hebt opgespoord en getest, maakt u de bestanden die moeten worden geïmplementeerd met uw app voor elk platform dat erop is gericht.

Ga als volgt te werk om uw app vanuit Visual Studio te publiceren:

1. Definieer de platformen waarop uw app is gericht.

   1. Klik met de rechtermuisknop op uw project (niet de oplossing) in Solution Explorer en selecteer SCD.csproj bewerken.

   2. Maak een <RuntimeIdentifiers> tag in de <PropertyGroup> sectie van uw csproj-bestand die de platformen definieert waarop uw app is gericht en geef de runtime-id (RID) op van elk platform waarop u zich richt. U moet ook een puntkomma toevoegen om de RID's te scheiden. Zie de runtime-id-catalogus voor een lijst met runtime-id's.

   In het volgende voorbeeld wordt bijvoorbeeld aangegeven dat de app wordt uitgevoerd op 64-bits Windows-besturingssystemen en het 64-bits OS X-besturingssysteem.

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

   Het <RuntimeIdentifiers> element kan ingaan op alle <PropertyGroup> elementen die u in uw csproj-bestand hebt. Verderop in deze sectie wordt een volledig csproj-voorbeeldbestand weergegeven.

2. Publiceer uw app.

   Nadat u fouten hebt opgespoord en getest, maakt u de bestanden die moeten worden geïmplementeerd met uw app voor elk platform dat erop is gericht.

   Ga als volgt te werk om uw app vanuit Visual Studio te publiceren:

   1. Wijzig de oplossingsconfiguratie van Foutopsporing in Release op de werkbalk om een releaseversie (in plaats van een foutopsporing) versie van uw app te bouwen.

   2. Klik met de rechtermuisknop op het project (niet de oplossing) in Solution Explorer en selecteer Publiceren.

   3. Selecteer Publiceren op het tabblad Publiceren. Visual Studio schrijft de bestanden die uit uw toepassing bestaan naar het lokale bestandssysteem.

   4. Het tabblad Publiceren toont nu één profiel, FolderProfile. De configuratie-instellingen van het profiel worden weergegeven in de sectie Samenvatting van het tabblad. Doelruntime identificeert welke runtime is gepubliceerd en doellocatie identificeert waar de bestanden voor de zelfstandige implementatie zijn geschreven.

   5. Visual Studio schrijft standaard alle gepubliceerde bestanden naar één map. Voor het gemak kunt u het beste afzonderlijke profielen maken voor elke doelruntime en gepubliceerde bestanden in een platformspecifieke map plaatsen. Dit omvat het maken van een afzonderlijk publicatieprofiel voor elk doelplatform. Bouw de toepassing nu opnieuw op voor elk platform door het volgende te doen:

      1. Selecteer Nieuw profiel maken in het dialoogvenster Publiceren .

      2. Wijzig in het dialoogvenster Een publicatiedoel kiezen de maplocatie kiezen in bin\Release\PublishOutput\win-x64. Selecteer OK.

      3. Selecteer het nieuwe profiel (FolderProfile1) in de lijst met profielen en zorg ervoor dat de doelruntime is win-x64. Als dat niet het is, selecteert u Instellingen. Wijzig in het dialoogvenster Profiel Instellingen de doelruntime in win-x64 en selecteer Opslaan. Anders selecteert u Annuleren.

      4. Selecteer Publiceren om uw app te publiceren voor 64-bits Windows 10-platforms.

      5. Volg de vorige stappen opnieuw om een profiel voor het osx-x64 platform te maken. De doellocatie is bin\Release\PublishOutput\osx-x64 en de doelruntime is osx-x64. De naam die Visual Studio aan dit profiel toewijst, is FolderProfile2.

   Elke doellocatie bevat de volledige set bestanden (zowel uw app-bestanden als alle .NET Core-bestanden) die nodig zijn om uw app te starten.

Samen met de bestanden van uw toepassing verzendt het publicatieproces een programmadatabasebestand (.pdb) dat foutopsporingsinformatie over uw app bevat. Het bestand is vooral handig voor het opsporen van fouten in uitzonderingen. U kunt ervoor kiezen deze niet te verpakken met de bestanden van uw toepassing. U moet deze echter opslaan in het geval dat u fouten wilt opsporen in de release-build van uw app.

Implementeer de gepubliceerde bestanden op elke gewenste manier. U kunt ze bijvoorbeeld inpakken in een Zip-bestand, een eenvoudige copy opdracht gebruiken of ze implementeren met elk installatiepakket van uw keuze.

Hier volgt het volledige csproj-bestand voor dit project.

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

Nadat u fouten hebt opgespoord en getest, maakt u de bestanden die moeten worden geïmplementeerd met uw app voor elk platform dat erop is gericht. Dit omvat het maken van een afzonderlijk profiel voor elk doelplatform.

Ga als volgt te werk voor elk platform waarop uw toepassing is gericht:

1. Maak een profiel voor uw doelplatform.

   Als dit het eerste profiel is dat u hebt gemaakt, klikt u met de rechtermuisknop op het project (niet de oplossing) in Solution Explorer en selecteert u Publiceren.

   Als u al een profiel hebt gemaakt, klikt u met de rechtermuisknop op het project om het dialoogvenster Publiceren te openen als dit nog niet is geopend. Selecteer vervolgens Nieuw profiel.

   Het dialoogvenster Doel publiceren kiezen wordt geopend.

2. Selecteer de locatie waar Visual Studio uw toepassing publiceert.

   Als u alleen naar één platform publiceert, kunt u de standaardwaarde in het tekstvak Een map kiezen accepteren. Hiermee wordt de frameworkafhankelijke implementatie van uw toepassing gepubliceerd naar de <projectmap>\bin\Release\netcoreapp2.1\publish directory.

   Als u publiceert naar meer dan één platform, voegt u een tekenreeks toe die het doelplatform identificeert. Als u bijvoorbeeld de tekenreeks Linux toevoegt aan het bestandspad, publiceert Visual Studio de frameworkafhankelijke implementatie van uw toepassing naar de <map project-directory>\bin\Release\netcoreapp2.1\publish\linux .

3. Maak het profiel door het vervolgkeuzelijstpictogram naast de knop Publiceren te selecteren en Profiel maken te selecteren. Selecteer vervolgens de knop Profiel maken om het profiel te maken.

4. Geef aan dat u een zelfstandige implementatie publiceert en een platform definieert waarop uw app is gericht.

   1. Selecteer in het dialoogvenster Publiceren de koppeling Configureren om het dialoogvenster Profiel Instellingen te openen.

   2. Selecteer Zelfstandig in de keuzelijst Implementatiemodus.

   3. Selecteer in de keuzelijst Target Runtime een van de platforms waarop uw toepassing is gericht.

   4. Selecteer Opslaan om uw wijzigingen te accepteren en sluit het dialoogvenster.

5. Geef uw profiel een naam.

   1. Selecteer Acties>naam van profiel wijzigen om uw profiel een naam te geven.

   2. Wijs uw profiel een naam toe die het doelplatform identificeert en selecteer vervolgens *Opslaan.

Herhaal deze stappen om aanvullende doelplatforms te definiëren die door uw toepassing worden gericht.

U hebt uw profielen geconfigureerd en bent nu klaar om uw app te publiceren. Dit doet u als volgt:

1. Als het venster Publiceren momenteel niet is geopend, klikt u met de rechtermuisknop op het project (niet de oplossing) in Solution Explorer en selecteert u Publiceren.

2. Selecteer het profiel dat u wilt publiceren en selecteer vervolgens Publiceren. Doe dit voor elk profiel dat moet worden gepubliceerd.

Elke doellocatie (in het geval van ons voorbeeld bin\release\netcoreapp2.1\publish\profile-name) bevat de volledige set bestanden (zowel uw app-bestanden als alle .NET Core-bestanden) die nodig zijn om uw app te starten.

Samen met de bestanden van uw toepassing verzendt het publicatieproces een programmadatabasebestand (.pdb) dat foutopsporingsinformatie over uw app bevat. Het bestand is vooral handig voor het opsporen van fouten in uitzonderingen. U kunt ervoor kiezen deze niet te verpakken met de bestanden van uw toepassing. U moet deze echter opslaan in het geval dat u fouten wilt opsporen in de release-build van uw app.

Implementeer de gepubliceerde bestanden op elke gewenste manier. U kunt ze bijvoorbeeld inpakken in een Zip-bestand, een eenvoudige copy opdracht gebruiken of ze implementeren met elk installatiepakket van uw keuze.

Hier volgt het volledige csproj-bestand voor dit project.

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

Daarnaast maakt Visual Studio een afzonderlijk publicatieprofiel (*.pubxml) voor elk platform waarop u zich richt. Het bestand voor ons Linux-profiel (linux.pubxml) wordt bijvoorbeeld als volgt weergegeven:

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

Zelfstandige implementatie met afhankelijkheden van derden

Het implementeren van een zelfstandige implementatie met een of meer afhankelijkheden van derden omvat het toevoegen van de afhankelijkheden. De volgende extra stappen zijn vereist voordat u uw app kunt bouwen:

1. Gebruik de NuGet-Pakketbeheer om een verwijzing naar een NuGet-pakket toe te voegen aan uw project. Als het pakket nog niet beschikbaar is op uw systeem, installeert u het. Als u pakketbeheer wilt openen, selecteert u Tools>NuGet Pakketbeheer> Manage NuGet-pakketten voor oplossing.

2. Controleer of uw afhankelijkheden van derden (bijvoorbeeld Newtonsoft.Json) op uw systeem zijn geïnstalleerd en, als dat niet het is, installeert u deze. Op het tabblad Geïnstalleerd worden NuGet-pakketten weergegeven die op uw systeem zijn geïnstalleerd. Als Newtonsoft.Json hier niet wordt vermeld, selecteert u het tabblad Bladeren en voert u Newtonsoft.Json in het zoekvak in. Selecteer Newtonsoft.Json en selecteer uw project in het rechterdeelvenster voordat u Installeren selecteert.

3. Als Newtonsoft.Json het systeem al is geïnstalleerd, voegt u het toe aan uw project door uw project te selecteren in het rechterdeelvenster van het tabblad Pakketten voor oplossing beheren.

Hier volgt het volledige csproj-bestand voor dit project:

Visual Studio 15.6 en eerder

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

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

Wanneer u uw toepassing implementeert, worden alle afhankelijkheden van derden die in uw app worden gebruikt, ook opgenomen in uw toepassingsbestanden. Bibliotheken van derden zijn niet vereist op het systeem waarop de app wordt uitgevoerd.

U kunt alleen een zelfstandige implementatie implementeren met een bibliotheek van derden op platforms die door die bibliotheek worden ondersteund. Dit is vergelijkbaar met het hebben van afhankelijkheden van derden met systeemeigen afhankelijkheden in uw frameworkafhankelijke implementatie, waarbij de systeemeigen afhankelijkheden niet bestaan op het doelplatform, tenzij ze daar eerder zijn geïnstalleerd.

Zie ook

• .NET Core-toepassingsimplementatie
• RID-catalogus (.NET Core Runtime Identifier)