Développement de bibliothèques avec des outils multiplateformesDeveloping Libraries with Cross Platform Tools

Cet article explique comment écrire des bibliothèques pour .NET à l’aide des outils CLI multiplateformes.This article covers how to write libraries for .NET using cross-platform CLI tools. L’interface CLI fournit une expérience efficace et de bas niveau qui fonctionne sur tous les systèmes d’exploitation pris en charge.The CLI provides an efficient and low-level experience that works across any supported OS. Vous pouvez toujours créer des bibliothèques avec Visual Studio, et si c’est ce que vous préférez, consultez le guide Visual Studio.You can still build libraries with Visual Studio, and if that is your preferred experience refer to the Visual Studio guide.

PrérequisPrerequisites

Le SDK .NET Core et l’interface CLI doivent être installés sur votre ordinateur.You need the .NET Core SDK and CLI installed on your machine.

Pour accéder aux sections de ce document concernant les versions du .NET Framework, vous devez installer le .NET Framework sur un ordinateur Windows.For the sections of this document dealing with .NET Framework versions, you need the .NET Framework installed on a Windows machine.

De plus, si vous voulez prendre en charge des cibles .NET Framework antérieures, vous devez installer les packs de ciblage/développeur des versions antérieures du Framework à partir de la page de plateformes cibles .NET.Additionally, if you wish to support older .NET Framework targets, you need to install targeting/developer packs for older framework versions from the .NET target platforms page. Reportez-vous au tableau suivant :Refer to this table:

Version du .NET Framework.NET Framework Version À téléchargerWhat to download
4.6.14.6.1 Pack de ciblage .NET Framework 4.6.1.NET Framework 4.6.1 Targeting Pack
4.64.6 Pack de ciblage .NET Framework 4.6.NET Framework 4.6 Targeting Pack
4.5.24.5.2 Pack du développeur .NET Framework 4.5.2.NET Framework 4.5.2 Developer Pack
4.5.14.5.1 Pack du développeur .NET Framework 4.5.1.NET Framework 4.5.1 Developer Pack
4.54.5 SDK Windows pour Windows 8Windows Software Development Kit for Windows 8
4.04.0 SDK pour Windows 7 et .NET Framework 4Windows SDK for Windows 7 and .NET Framework 4
2.0, 3.0 et 3.52.0, 3.0, and 3.5 Runtime .NET Framework 3.5 SP1 (ou version Windows 8+).NET Framework 3.5 SP1 Runtime (or Windows 8+ version)

Comment cibler .NET StandardHow to target the .NET Standard

Si vous ne connaissez pas très bien .NET Standard, référez-vous à la page .NET Standard pour en savoir plus.If you're not quite familiar with the .NET Standard, refer to the .NET Standard to learn more.

Voici un tableau qui associe les versions .NET Standard à diverses implémentations :In that article, there is a table which maps .NET Standard versions to various implementations:

.NET Standard.NET Standard 1.01.0 1.11.1 1.21.2 1.31.3 1.41.4 1.51.5 1.61.6 2.02.0
.NET Core.NET Core 1.01.0 1.01.0 1.01.0 1.01.0 1.01.0 1.01.0 1.01.0 2.02.0
.NET Framework 1.NET Framework 1 4.54.5 4.54.5 4.5.14.5.1 4.64.6 4.6.14.6.1 4.6.14.6.1 4.6.14.6.1 4.6.14.6.1
MonoMono 4.64.6 4.64.6 4.64.6 4.64.6 4.64.6 4.64.6 4.64.6 5,45.4
Xamarin.iOSXamarin.iOS 10.010.0 10.010.0 10.010.0 10.010.0 10.010.0 10.010.0 10.010.0 10.1410.14
Xamarin.MacXamarin.Mac 3.03.0 3.03.0 3.03.0 3.03.0 3.03.0 3.03.0 3.03.0 3.83.8
Xamarin.AndroidXamarin.Android 7.07.0 7.07.0 7.07.0 7.07.0 7.07.0 7.07.0 7.07.0 8.08.0
Plateforme Windows universelleUniversal Windows Platform 10.010.0 10.010.0 10.010.0 10.010.0 10.010.0 10.0.1629910.0.16299 10.0.1629910.0.16299 10.0.1629910.0.16299
WindowsWindows 8.08.0 8.08.0 8.18.1
Windows PhoneWindows Phone 8.18.1 8.18.1 8.18.1
Windows Phone SilverlightWindows Phone Silverlight 8.08.0

1. Les versions listées pour le .NET Framework s’appliquent au kit SDK .NET Core 2.0 et ultérieur des outils. Les versions antérieures utilisent un autre mappage pour .NET Standard 1.5 et versions ultérieures. Vous pouvez télécharger les outils pour Outils .NET Core pour Visual Studio 2015 si vous ne pouvez pas mettre à niveau vers Visual Studio 2017.1 The versions listed for .NET Framework apply to .NET Core SDK 2.0 and later versions of the tooling. Older versions used a different mapping for .NET Standard 1.5 and higher. You can download tooling for .NET Core tools for Visual Studio 2015 if you cannot upgrade to Visual Studio 2017.

  • Les colonnes représentent les versions de .NET Standard.The columns represent .NET Standard versions. Chaque cellule d’en-tête est un lien vers un document qui indique les API ajoutées à cette version de .NET Standard.Each header cell is a link to a document that shows which APIs got added in that version of .NET Standard.
  • Les lignes représentent les différentes implémentations .NET.The rows represent the different .NET implementations.
  • Le numéro de version dans chaque cellule indique la version minimale de l’implémentation nécessaire pour cibler cette version de .NET Standard.The version number in each cell indicates the minimum version of the implementation you'll need in order to target that .NET Standard version.
  • Pour un tableau interactif, consultez Versions .NET Standard.For an interactive table, see .NET Standard versions.

Voici ce que signifie ce tableau dans le processus de création d’une bibliothèque :Here's what this table means for the purposes of creating a library:

La version de .NET Standard que vous choisissez est un compromis entre l’accès aux API les plus récentes et la possibilité de cibler plus d’implémentations .NET et de versions .NET Standard.The version of the .NET Standard you pick will be a tradeoff between access to the newest APIs and the ability to target more .NET implementations and .NET Standard versions. Vous contrôlez la plage de versions et de plateformes pouvant être ciblées en sélectionnant une version de netstandardX.X (où X.X est un numéro de version), puis en l’ajoutant à votre fichier projet (.csproj ou .fsproj).You control the range of targetable platforms and versions by picking a version of netstandardX.X (Where X.X is a version number) and adding it to your project file (.csproj or .fsproj).

Vous disposez de trois options principales quand vous ciblez .NET Standard, en fonction de vos besoins.You have three primary options when targeting the .NET Standard, depending on your needs.

  1. Vous pouvez utiliser la version par défaut de .NET Standard fournie par les modèles (netstandard1.4). Celle-ci vous donne accès à la plupart des API sur .NET Standard tout en étant compatible avec UWP, le .NET Framework  4.6.1 et le prochain .NET Standard 2.0.You can use the default version of the .NET Standard supplied by templates - netstandard1.4 - which gives you access to most APIs on .NET Standard while still being compatible with UWP, .NET Framework 4.6.1, and the forthcoming .NET Standard 2.0.

    <Project Sdk="Microsoft.NET.Sdk">
      <PropertyGroup>
        <TargetFramework>netstandard1.4</TargetFramework>
      </PropertyGroup>
    </Project>
    
  2. Vous pouvez utiliser une version inférieure ou supérieure de .NET Standard en modifiant la valeur dans le nœud TargetFramework de votre fichier projet.You can use a lower or higher version of the .NET Standard by modifying the value in the TargetFramework node of your project file.

    Les versions .NET standard sont à compatibilité descendante..NET Standard versions are backward compatible. Cela signifie que les bibliothèques netstandard1.0 s’exécutent sur les plateformes netstandard1.1 et versions ultérieures.That means that netstandard1.0 libraries run on netstandard1.1 platforms and higher. Toutefois, il n’existe pas de compatibilité ascendante : les plateformes .NET Standard antérieures ne peuvent pas référencer les plateformes ultérieures.However, there is no forward compatibility - lower .NET Standard platforms cannot reference higher ones. Cela signifie que les bibliothèques netstandard1.0 ne peuvent pas cibler des bibliothèques de référence ciblant netstandard1.1 ou une version ultérieure.This means that netstandard1.0 libraries cannot reference libraries targeting netstandard1.1 or higher. Sélectionnez la version Standard qui offre une bonne combinaison entre les API et la prise en charge de plateformes pour vos besoins.Select the Standard version that has the right mix of APIs and platform support for your needs. Nous vous recommandons d’utiliser netstandard1.4 pour l’instant.We recommend netstandard1.4 for now.

  3. Si vous voulez cibler les versions .NET Framework 4.0 ou antérieures, ou que vous voulez utiliser une API disponible dans le .NET Framework, mais pas dans .NET Standard (par exemple, System.Drawing), lisez les sections suivantes et découvrez comment réaliser un multiciblage.If you want to target the .NET Framework versions 4.0 or below, or you wish to use an API available in the .NET Framework but not in the .NET Standard (for example, System.Drawing), read the following sections and learn how to multitarget.

Comment cibler le .NET FrameworkHow to target the .NET Framework

Note

Les instructions suivantes supposent que le .NET Framework est installé sur votre ordinateur.These instructions assume you have the .NET Framework installed on your machine. Reportez-vous aux Prérequis pour installer les dépendances.Refer to the Prerequisites to get dependencies installed.

N’oubliez pas que certaines des versions du .NET Framework utilisées ici ne sont plus prises en charge.Keep in mind that some of the .NET Framework versions used here are no longer in support. Reportez-vous au Forum aux questions sur la politique de support de Microsoft .NET Framework concernant les versions non prises en charge.Refer to the .NET Framework Support Lifecycle Policy FAQ about unsupported versions.

Si vous voulez atteindre le nombre maximal de développeurs et de projets, utilisez le .NET Framework 4.0 comme cible de base de référence.If you want to reach the maximum number of developers and projects, use the .NET Framework 4.0 as your baseline target. Pour cibler le .NET Framework, vous devez commencer par utiliser le Moniker du Framework cible approprié qui correspond à la version du .NET Framework que vous voulez prendre en charge.To target the .NET Framework, you will need to begin by using the correct Target Framework Moniker (TFM) that corresponds to the .NET Framework version you wish to support.

.NET Framework 2.0   --> net20
.NET Framework 3.0   --> net30
.NET Framework 3.5   --> net35
.NET Framework 4.0   --> net40
.NET Framework 4.5   --> net45
.NET Framework 4.5.1 --> net451
.NET Framework 4.5.2 --> net452
.NET Framework 4.6   --> net46
.NET Framework 4.6.1 --> net461
.NET Framework 4.6.2 --> net462
.NET Framework 4.7   --> net47

Insérez ensuite ce Moniker du Framework cible dans la section TargetFramework de votre fichier projet.You then insert this TFM into the TargetFramework section of your project file. Par exemple, voici comment écrire une bibliothèque qui cible le .NET Framework 4.0 :For example, here's how you would write a library which targets the .NET Framework 4.0:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net40</TargetFramework>
  </PropertyGroup>
</Project>

Et voilà !And that's it! Bien que ce code se compilait uniquement pour .NET Framework 4, vous pouvez utiliser la bibliothèque sur des versions plus récentes du .NET Framework.Although this compiled only for the .NET Framework 4, you can use the library on newer versions of the .NET Framework.

Comment multiciblerHow to Multitarget

Note

Les instructions suivantes supposent que le .NET Framework est installé sur votre ordinateur.The following instructions assume you have the .NET Framework installed on your machine. Reportez-vous à la section Prérequis pour savoir quelles dépendances doivent être installées et à partir d’où les télécharger.Refer to the Prerequisites section to learn which dependencies you need to install and where to download them from.

Vous devrez peut-être cibler des versions antérieures du .NET Framework si votre projet prend en charge à la fois .NET Framework et .NET Core.You may need to target older versions of the .NET Framework when your project supports both the .NET Framework and .NET Core. Dans ce scénario, si vous voulez utiliser des API et des constructions de langage plus récentes pour des cibles plus récentes, utilisez des directives #if dans votre code.In this scenario, if you want to use newer APIs and language constructs for the newer targets, use #if directives in your code. Vous pouvez aussi avoir besoin d’ajouter différents packages et différentes dépendances pour chaque plateforme que vous ciblez pour inclure les différentes API nécessaires à chaque cas.You also might need to add different packages and dependencies for each platform you're targeting to include the different APIs needed for each case.

Supposons, par exemple, que vous avez une bibliothèque qui effectue des opérations réseau sur HTTP.For example, let's say you have a library that performs networking operations over HTTP. Pour .NET Standard et les versions .NET Framework 4.5 ou ultérieures, vous pouvez utiliser la classe HttpClient à partir de l’espace de noms System.Net.Http.For .NET Standard and the .NET Framework versions 4.5 or higher, you can use the HttpClient class from the System.Net.Http namespace. Toutefois, les versions antérieures du .NET Framework ne disposent pas de la classe HttpClient. Vous pourriez donc utiliser la classe WebClient à partir de l’espace de noms System.Net à la place.However, earlier versions of the .NET Framework don't have the HttpClient class, so you could use the WebClient class from the System.Net namespace for those instead.

Voici à quoi peut ressembler votre fichier projet :Your project file could look like this:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>netstandard1.4;net40;net45</TargetFrameworks>
  </PropertyGroup>

  <!-- Need to conditionally bring in references for the .NET Framework 4.0 target -->
  <ItemGroup Condition="'$(TargetFramework)' == 'net40'">
    <Reference Include="System.Net" />
  </ItemGroup>

  <!-- Need to conditionally bring in references for the .NET Framework 4.5 target -->
  <ItemGroup Condition="'$(TargetFramework)' == 'net45'">
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Threading.Tasks" />
  </ItemGroup>
</Project>

Notez trois changements majeurs ici :You'll notice three major changes here:

  1. Le nœud TargetFramework a été remplacé par TargetFrameworks, et trois Monikers du Framework cible sont exprimés à l’intérieur.The TargetFramework node has been replaced by TargetFrameworks, and three TFMs are expressed inside.
  2. Un nœud <ItemGroup> est présent pour l’extraction de cible net40 dans une référence .NET Framework.There is an <ItemGroup> node for the net40 target pulling in one .NET Framework reference.
  3. Un nœud <ItemGroup> est présent pour l’extraction de cible net45 dans deux références .NET Framework.There is an <ItemGroup> node for the net45 target pulling in two .NET Framework references.

Le système de build est informé des symboles de préprocesseur suivants utilisés dans les directives #if:The build system is aware of the following preprocessor symbols used in #if directives:

Versions cibles de .NET FrameworkTarget Frameworks SymbolesSymbols
.NET Framework.NET Framework NET20, NET35, NET40, NET45, NET451, NET452, NET46, NET461, NET462, NET47, NET471, NET472NET20, NET35, NET40, NET45, NET451, NET452, NET46, NET461, NET462, NET47, NET471, NET472
.NET Standard.NET Standard NETSTANDARD1_0, NETSTANDARD1_1, NETSTANDARD1_2, NETSTANDARD1_3, NETSTANDARD1_4, NETSTANDARD1_5, NETSTANDARD1_6, NETSTANDARD2_0NETSTANDARD1_0, NETSTANDARD1_1, NETSTANDARD1_2, NETSTANDARD1_3, NETSTANDARD1_4, NETSTANDARD1_5, NETSTANDARD1_6, NETSTANDARD2_0
.NET Core.NET Core NETCOREAPP1_0, NETCOREAPP1_1, NETCOREAPP2_0, NETCOREAPP2_1, NETCOREAPP2_2NETCOREAPP1_0, NETCOREAPP1_1, NETCOREAPP2_0, NETCOREAPP2_1, NETCOREAPP2_2

Voici un exemple d’utilisation de la compilation conditionnelle par cible :Here is an example making use of conditional compilation per-target:

using System;
using System.Text.RegularExpressions;
#if NET40
// This only compiles for the .NET Framework 4 targets
using System.Net;
#else
 // This compiles for all other targets
using System.Net.Http;
using System.Threading.Tasks;
#endif

namespace MultitargetLib
{
    public class Library
    {
#if NET40
        private readonly WebClient _client = new WebClient();
        private readonly object _locker = new object();
#else
        private readonly HttpClient _client = new HttpClient();
#endif

#if NET40
        // .NET Framework 4.0 does not have async/await
        public string GetDotNetCount()
        {
            string url = "http://www.dotnetfoundation.org/";

            var uri = new Uri(url);

            string result = "";

            // Lock here to provide thread-safety.
            lock(_locker)
            {
                result = _client.DownloadString(uri);
            }

            int dotNetCount = Regex.Matches(result, ".NET").Count;

            return $"Dotnet Foundation mentions .NET {dotNetCount} times!";
        }
#else
        // .NET 4.5+ can use async/await!
        public async Task<string> GetDotNetCountAsync()
        {
            string url = "http://www.dotnetfoundation.org/";

            // HttpClient is thread-safe, so no need to explicitly lock here
            var result = await _client.GetStringAsync(url);

            int dotNetCount = Regex.Matches(result, ".NET").Count;

            return $"dotnetfoundation.org mentions .NET {dotNetCount} times in its HTML!";
        }
#endif
    }
}

Si vous générez ce projet avec dotnet build, notez la présence de trois répertoires sous le dossier bin/ :If you build this project with dotnet build, you'll notice three directories under the bin/ folder:

net40/
net45/
netstandard1.4/

Chacun d’entre eux contient les fichiers .dll pour chaque cible.Each of these contain the .dll files for each target.

Comment tester les bibliothèques sur .NET CoreHow to test libraries on .NET Core

Il est important de pouvoir effectuer des tests sur plusieurs plateformes.It's important to be able to test across platforms. Vous pouvez utiliser xUnit ou MSTest dans leur version d’origine.You can use either xUnit or MSTest out of the box. Les deux conviennent parfaitement à la réalisation de tests unitaires sur votre bibliothèque sur .NET Core.Both are perfectly suitable for unit testing your library on .NET Core. La façon dont vous configurez votre solution avec des projets de test dépend de la structure de votre solution.How you set up your solution with test projects will depend on the structure of your solution. L’exemple suivant part du principe que les répertoires de test et source résident dans le même répertoire de premier niveau.The following example assumes that the test and source directories live in the same top-level directory.

Note

Cet exemple utilise certaines commandes CLI .NET Core.This uses some .NET Core CLI commands. Pour plus d’informations, consultez dotnet new et dotnet sln.See dotnet new and dotnet sln for more information.

  1. Configurez votre solution.Set up your solution. Pour cela, utilisez la commande suivante :You can do so with the following commands:

    mkdir SolutionWithSrcAndTest
    cd SolutionWithSrcAndTest
    dotnet new sln
    dotnet new classlib -o MyProject
    dotnet new xunit -o MyProject.Test
    dotnet sln add MyProject/MyProject.csproj
    dotnet sln add MyProject.Test/MyProject.Test.csproj
    

    Cette commande crée des projets et les relie dans une solution.This will create projects and link them together in a solution. Votre répertoire pour SolutionWithSrcAndTest doit ressembler à ceci :Your directory for SolutionWithSrcAndTest should look like this:

    /SolutionWithSrcAndTest
    |__SolutionWithSrcAndTest.sln
    |__MyProject/
    |__MyProject.Test/
    
  2. Accédez au répertoire du projet de test et ajoutez une référence à MyProject.Test à partir de MyProject.Navigate to the test project's directory and add a reference to MyProject.Test from MyProject.

    cd MyProject.Test
    dotnet add reference ../MyProject/MyProject.csproj
    
  3. Restaurez les packages et générez les projets :Restore packages and build projects:

    dotnet restore
    dotnet build
    

    Note

    À compter de .NET Core 2.0, vous n’avez pas à exécuter dotnet restore, car il est exécuté implicitement par toutes les commandes qui nécessitent une restauration, comme dotnet new, dotnet build et dotnet run.Starting with .NET Core 2.0, you don't have to run dotnet restore because it's run implicitly by all commands that require a restore to occur, such as dotnet new, dotnet build and dotnet run. Cette commande reste néanmoins valide dans certains scénarios où une restauration explicite est nécessaire, comme des builds d’intégration continue dans Azure DevOps Services ou dans les systèmes de génération qui doivent contrôler explicitement le moment auquel la restauration se produit.It's still a valid command in certain scenarios where doing an explicit restore makes sense, such as continuous integration builds in Azure DevOps Services or in build systems that need to explicitly control the time at which the restore occurs.

  4. Exécutez la commande dotnet test pour vérifier que xUnit s’exécute.Verify that xUnit runs by executing the dotnet test command. Si vous avez choisi d’utiliser MSTest, le Test Runner de console MSTest doit s’exécuter à la place.If you chose to use MSTest, then the MSTest console runner should run instead.

Et voilà !And that's it! Vous pouvez maintenant tester votre bibliothèque sur toutes les plateformes à l’aide des outils en ligne de commande.You can now test your library across all platforms using command line tools. Maintenant que vous avez tout configuré, le test de votre bibliothèque est très simple :To continue testing now that you have everything set up, testing your library is very simple:

  1. Apportez des modifications à votre bibliothèque.Make changes to your library.
  2. Exécutez les tests à partir de la ligne de commande, dans votre répertoire de test, avec la commande dotnet test.Run tests from the command line, in your test directory, with dotnet test command.

Votre code est automatiquement régénéré quand vous appelez la commande dotnet test.Your code will be automatically rebuilt when you invoke dotnet test command.

Comment utiliser plusieurs projetsHow to use multiple projects

Les bibliothèques plus volumineuses ont souvent besoin de placer des fonctionnalités dans différents projets.A common need for larger libraries is to place functionality in different projects.

Imaginez que vous vouliez créer une bibliothèque pouvant être utilisée en langage C# et F#.Imagine you wished to build a library which could be consumed in idiomatic C# and F#. Cela signifierait que les consommateurs de votre bibliothèque les utilisent dans des formes qui sont naturelles en C# ou F#.That would mean that consumers of your library consume them in ways which are natural to C# or F#. Par exemple, en C#, vous pouvez utiliser la bibliothèque de la façon suivante :For example, in C# you might consume the library like this:

using AwesomeLibrary.CSharp;

public Task DoThings(Data data)
{
    var convertResult = await AwesomeLibrary.ConvertAsync(data);
    var result = AwesomeLibrary.Process(convertResult);
    // do something with result
}

En F#, le code peut se présenter comme suit :In F#, it might look like this:

open AwesomeLibrary.FSharp

let doWork data = async {
    let! result = AwesomeLibrary.AsyncConvert data // Uses an F# async function rather than C# async method
    // do something with result
}

Les scénarios de consommation tels que celui-ci signifient que les API auxquelles vous accédez ont une structure différente en C# et F#.Consumption scenarios like this mean that the APIs being accessed have to have a different structure for C# and F#. Pour réaliser ceci, il est courant de factoriser toute la logique d’une bibliothèque dans un projet principal et d’avoir des projets C# et F# définissant les couches API qui effectuent des appels à ce projet principal.A common approach to accomplishing this is to factor all of the logic of a library into a core project, with C# and F# projects defining the API layers that call into that core project. Le reste de la section utilise les noms suivants :The rest of the section will use the following names:

  • AwesomeLibrary.Core : projet principal qui contient toute la logique de la bibliothèqueAwesomeLibrary.Core - A core project which contains all logic for the library
  • AwesomeLibrary.CSharp : projet avec des API publiques destinées à être consommées en C#AwesomeLibrary.CSharp - A project with public APIs intended for consumption in C#
  • AwesomeLibrary.CSharp : projet avec des API publiques destinées à être consommées en F#AwesomeLibrary.FSharp - A project with public APIs intended for consumption in F#

Vous pouvez exécuter les commandes suivantes dans votre terminal pour produire la même structure que ce guide :You can run the following commands in your terminal to produce the same structure as this guide:

mkdir AwesomeLibrary && cd AwesomeLibrary
dotnet new sln
mkdir AwesomeLibrary.Core && cd AwesomeLibrary.Core && dotnet new classlib
cd ..
mkdir AwesomeLibrary.CSharp && cd AwesomeLibrary.CSharp && dotnet new classlib
cd ..
mkdir AwesomeLibrary.FSharp && cd AwesomeLibrary.FSharp && dotnet new classlib -lang F#
cd ..
dotnet sln add AwesomeLibrary.Core/AwesomeLibrary.Core.csproj
dotnet sln add AwesomeLibrary.CSharp/AwesomeLibrary.CSharp.csproj
dotnet sln add AwesomeLibrary.FSharp/AwesomeLibrary.FSharp.fsproj

Cette opération ajoute les trois projets ci-dessus et un fichier solution qui les relie.This will add the three projects above and a solution file which links them together. Le fait de créer le fichier solution et de lier des projets vous permet de restaurer et de générer des projets à partir d’un niveau supérieur.Creating the solution file and linking projects will allow you to restore and build projects from a top-level.

Références entre projetsProject-to-project referencing

La meilleure façon de référencer un projet consiste à utiliser l’interface CLI .NET Core pour ajouter une référence de projet.The best way to reference a project is to use the .NET Core CLI to add a project reference. À partir des répertoires de projet AwesomeLibrary.CSharp et de AwesomeLibrary.FSharp, vous pouvez exécuter la commande suivante :From the AwesomeLibrary.CSharp and AwesomeLibrary.FSharp project directories, you can run the following command:

$ dotnet add reference ../AwesomeLibrary.Core/AwesomeLibrary.Core.csproj

Les fichiers projet pour AwesomeLibrary.CSharp et AwesomeLibrary.FSharp référencent désormais AwesomeLibrary.Core comme cible de ProjectReference.The project files for both AwesomeLibrary.CSharp and AwesomeLibrary.FSharp will now reference AwesomeLibrary.Core as a ProjectReference target. Pour le vérifier, confirmez la présence des éléments suivants dans les fichiers projet :You can verify this by inspecting the project files and seeing the following in them:

<ItemGroup>
  <ProjectReference Include="..\AwesomeLibrary.Core\AwesomeLibrary.Core.csproj" />
</ItemGroup>

Vous pouvez ajouter manuellement cette section à chaque fichier projet si vous préférez ne pas utiliser l’interface CLI .NET Core.You can add this section to each project file manually if you prefer not to use the .NET Core CLI.

Structurer une solutionStructuring a solution

Un autre aspect important des solutions à projets multiples est la mise en place d’une bonne structure de projet globale.Another important aspect of multi-project solutions is establishing a good overall project structure. Vous pouvez organiser le code comme vous le souhaitez, et tant que vous liez chaque projet à votre fichier solution avec dotnet sln add, vous pouvez exécuter dotnet restore et dotnet build au niveau de la solution.You can organize code however you like, and as long as you link each project to your solution file with dotnet sln add, you will be able to run dotnet restore and dotnet build at the solution level.