Relation entre le dotnet cli et le nouveau vs2017 msbuild
Avec le passage de project.json au nouveau format csproj introduit avec VS2017, j'ai du mal à comprendre la différence entre le dotnetcli et le nouveau msbuild et à utiliser l'un sur l'autre .
1) Pour construire une nouvelle bibliothèque csproj netstandard à partir de la ligne de commande, devrais-je appeler la dotnet cli (par exemple, dotnet restoredotnet build) ou utilisez msbuild (par exemple msbuild ExampleNetstandard.sln).
2) De plus, si j'ai bien compris, il existe deux versions de msbuild, l'une reposant sur la structure complète et l'autre sur le ciblage dotnet core. Est-ce correct? Dois-je toujours utiliser le dotnet version
3) est dotnet cli autonome ou nécessite-t-il que msbuild soit installé ?. Par exemple, lorsque vous installez le kit de développement logiciel (SDK) dotnet, installez-vous également msbuild? Si tel est le cas, est-ce différent de la version installée avec vs2017?
Des questions
1) Pour construire une nouvelle bibliothèque csproj netstandard à partir de la ligne de commande, devrais-je appeler le cli dotnet (par exemple, dotnet restore dotnet build) ou utiliser msbuild (par exemple, msbuild ExampleNetstandard.sln).
Les deux fonctionnent bien car dotnet est actuellement construit sur msbuild. C'est donc une question de goût. Vous pouvez également appeler les tâches msbuild à l’aide de la CLI DOTNET. (dotnet msbuild <msbuild_arguments>)
Au début, tout le matériel de base .NET était uniquement dans dotnet et non dans msbuild. C'était fastidieux, car beaucoup de choses déjà construites sur msbuild ne fonctionnaient pas bien avec dotnet prêt à l'emploi (par exemple, Xamarin). Ils ont donc déplacé le contenu dans msbuild et construit dotnet au-dessus de msbuild.
dotnet a certaines fonctionnalités qui ne sont pas dans msbuild, comme dotnet new. À mon avis, dotnet est plus facile à utiliser que msbuild, je préfère donc dotnet.
Pour que ce soit plus clair, j'ai ajouté une comparaison entre msbuild et dotnet à la fin de mon message.
2) De plus, si j'ai bien compris, il existe deux versions de msbuild, l'une basée sur la structure complète et l'autre centrée sur le noyau dotnet. Est-ce correct? Dois-je toujours utiliser la version dotnet
Il n'y a qu'un seul msbuild. La CLI de dotnet utilise msbuild:
Etant donné que CLI utilise MSBuild comme moteur de génération, il est recommandé d’écrire ces parties de l’outil en tant que cibles et tâches MSBuild personnalisées, car elles peuvent alors prendre part au processus de construction global.
https://docs.Microsoft.com/en-us/dotnet/articles/core/tools/extensibility
L'ancienne version de msbuild ne disposait pas du support .NET Core. Peut-être que c'est l'autre version;)
Je suis d'accord que c'est déroutant, car c'était très différent il y a quelques mois.
3) dotnet cli est-il autonome ou nécessite-t-il l'installation de msbuild?. Par exemple, lorsque vous installez le kit de développement logiciel (SDK) dotnet, installez-vous également msbuild? Si tel est le cas, est-ce différent de la version installée avec vs2017?
Je n'étais pas sûr de cela, mais c'était facile à tester. J'ai supprimé tous les msbuild.exe et cela fonctionnait toujours. Découvert qu'il utilise le msbuild.dll dans le dossier du SDK. par exemple. "C:\Program Files\dotnet\sdk\1.0.3\MSBuild.dll"
Si vous supprimez celui-là, il y a une preuve:
msbuild.dll est en fait msbuild.exe, comme vous pouvez le constater dans les propriétés:
Du code
Si vous regardez dans le code de la CLI de dotnet, vous pouvez voir qu'il génère des commandes msbuild.
Par exemple dotnet restore, est créé par la RestoreCommand class à l'intérieur de la CLI de dotnet .
Une version dépouillée:
public class RestoreCommand : MSBuildForwardingApp
{
...
public static RestoreCommand FromArgs(string[] args, string msbuildPath = null)
{
var result = parser.ParseFrom("dotnet restore", args);
...
var msbuildArgs = new List<string>
{
"/NoLogo",
"/t:Restore",
"/ConsoleLoggerParameters:Verbosity=Minimal"
};
...
return new RestoreCommand(msbuildArgs, msbuildPath);
}
public static int Run(string[] args)
{
RestoreCommand cmd;
try
{
cmd = FromArgs(args);
}
catch (CommandCreationException e)
{
return e.ExitCode;
}
return cmd.Execute();
}
...
}
Tu peux voir dotnet restore appelle juste msbuild /NoLogo /t:Restore /ConsoleLoggerParameters:Verbosity=Minimal
Si vous cochez RestoreCommand au temps de dotnet v1.0.0 RC2 , il n’utilisait pas msbuild mais appelait directement nuget.
return NuGet3.Restore(args, quiet);
Correspondance entre dotnet et msbuild
J'ai fait un mapping entre dotnet et msbuild. Ce n'est pas complet, mais les commandes importantes sont là.
Dotnet | Msbuild | Remarks
-----------------------|--------------------------------------------|---------------------------------
Add | |
-----------------------|--------------------------------------------|---------------------------------
Build | /t:Build |
-----------------------|--------------------------------------------|---------------------------------
Build --no-incremental | /t:Rebuild |
-----------------------|--------------------------------------------|---------------------------------
Clean | /t:clean |
-----------------------|--------------------------------------------|---------------------------------
Complete | |
-----------------------|--------------------------------------------|---------------------------------
Help | | Help!
-----------------------|--------------------------------------------|---------------------------------
List | |
-----------------------|--------------------------------------------|---------------------------------
Migrate | - |
-----------------------|--------------------------------------------|---------------------------------
Msbuild | | Forwarding all
-----------------------|--------------------------------------------|---------------------------------
New | |
-----------------------|--------------------------------------------|---------------------------------
Nuget | | *
-----------------------|--------------------------------------------|---------------------------------
Pack | /t:pack |
-----------------------|--------------------------------------------|---------------------------------
Publish | /t:publish |
-----------------------|--------------------------------------------|---------------------------------
Remove | |
-----------------------|--------------------------------------------|---------------------------------
Restore | /NoLogo /t:Restore |
/ConsoleLoggerParameters:Verbosity=Minimal |
-----------------------|--------------------------------------------|---------------------------------
Run | /nologo /verbosity:quiet |
/p:Configuration= /p:TargetFramework |
-----------------------|--------------------------------------------|---------------------------------
Sln | | Not in msbuild
-----------------------|--------------------------------------------|---------------------------------
Store | /t:ComposeStore |
-----------------------|--------------------------------------------|---------------------------------
Test | /t:VSTest /v:quiet /nologo |
-----------------------|--------------------------------------------|---------------------------------
Vstest | | Forwarding to vstest.console.dll
* nuget dotnet: Ajout/suppression de packages dans csproj, ensemble également limité de nuget.exe, voir comparaison