Partager via

Fonctions de propriétés

  • Article

Les fonctions de propriété sont des appels à des méthodes .NET qui apparaissent dans les définitions de propriétés MSBuild. Au contraire des tâches, les fonctions de propriété peuvent être utilisées en dehors des cibles. Les fonctions de propriété sont évaluées chaque fois que les propriétés ou les éléments sont étendus. Ainsi, pour les propriétés et les éléments en dehors de cibles, les fonctions de propriété sont évaluées avant l’exécution de toute cible. Pour les groupes de propriétés et les groupes d’éléments à l’intérieur de cibles, les fonctions de propriété sont évaluées lors de l’évaluation de la cible.

Sans utiliser de tâches MSBuild, vous pouvez lire l'heure système, comparer des chaînes, établir des correspondances avec des expressions régulières et effectuer d'autres actions dans votre script de génération. MSBuild tente de convertir les chaînes en nombres et les nombres en chaînes, et d'effectuer les autres conversions nécessaires.

Les valeurs de chaîne retournées à partir de fonctions de propriété ont des caractères spéciaux d’échappement. Si vous souhaitez que la valeur soit traitée comme si elle avait été placée directement dans le fichier projet, utilisez $([MSBuild]::Unescape()) pour éliminer les caractères spéciaux d’échappement.

Syntaxe des fonctions de propriété

Il y a trois sortes de fonctions de propriété. Chaque fonction a une syntaxe différente :

  • Fonctions de propriété (d'instance) de chaîne
  • Fonctions de propriété statique
  • Fonctions de propriété MSBuild

Fonctions de propriété de type chaîne

Toutes les valeurs de propriété de build sont simplement des valeurs de chaîne. Vous pouvez utiliser des méthodes (d'instance) de chaîne pour effectuer des opérations sur toutes les valeurs de propriété. Par exemple, vous pouvez extraire le nom du lecteur (les trois premiers caractères) d’une propriété de build qui représente un chemin d’accès complet à l’aide de ce code :

$(ProjectOutputFolder.Substring(0,3))

Fonctions de propriété statique

Dans votre script de génération, vous pouvez accéder aux propriétés et aux méthodes statiques de nombreuses classes système. Pour obtenir la valeur d’une propriété statique, utilisez la syntaxe suivante, où Class est le nom de la classe système et Property est le nom de la propriété.

$([Class]::Property)

Par exemple, vous pouvez utiliser le code suivant pour définir une propriété de build avec la date et l'heure actuelles.

<Today>$([System.DateTime]::Now)</Today>

Pour appeler une méthode statique, utilisez la syntaxe suivante, où Class est le nom de la classe système, Method le nom de la méthode et (Parameters) la liste des paramètres pour la méthode :

$([Class]::Method(Parameters))

Par exemple, pour définir une propriété de build avec un nouveau GUID, vous pouvez utiliser ce script :

<NewGuid>$([System.Guid]::NewGuid())</NewGuid>

Dans les fonctions de propriété statique, vous pouvez utiliser toutes les méthodes ou propriétés statiques publiques définies dans .NET Standard 2.0 pour ces classes système :

Remarque

Les méthodes et les propriétés qui ne sont pas définies dans .NET Standard 2.0 peuvent être disponibles lorsque vous utilisez MSBuild dans un environnement qui les prend en charge, mais dont la disponibilité ne peut pas être garantie dans toutes les situations. Pour des raisons de compatibilité, il vaut mieux les éviter.

Vous pouvez également utiliser les méthodes et propriétés statiques suivantes :

Fonctions de la propriété System.OperatingSystem

Les fonctions de propriété System.OperatingSystem renvoient des informations sur le système d'exploitation sur lequel MSBuild est exécuté. Par exemple, si votre projet cible Linux et que vous le construisez sur macOS, les fonctions de propriété renverront des informations sur macOS.

Dans MSBuild exécuté sur .NET (dotnet build), toutes les méthodes statiques de la classe System.OperatingSystem pourront être appelées en tant que fonctions de propriété statique.

Dans MSBuild exécuté sur .NET Framework (MSBuild.exe), seules les méthodes suivantes System.OperatingSystem pourront être appelées en tant que fonctions de propriété statique. MSBuild les implémente en interne, car System.OperatingSystem ne les définit pas sur .NET Framework. Les méthodes des systèmes d'exploitation pour lesquels il n'existe pas de SDK .NET, telles que System.OperatingSystem::IsTvOS, ne peuvent pas être appelées.

L'exemple suivant montre l'utilisation de ces fonctions de propriété.

<IsWindows>$([System.OperatingSystem]::IsWindows())</IsWindows>

Appeler des méthodes d’instance sur des propriétés statiques

Si vous accédez à une propriété statique qui retourne une instance d'un objet, vous pouvez appeler les méthodes d'instance de cet objet. Pour appeler une méthode d’instance, utilisez la syntaxe suivante, où Class est le nom de la classe système, Property le nom de la propriété, Method le nom de la méthode et (Parameters) la liste des paramètres pour la méthode :

$([Class]::Property.Method(Parameters))

Le nom de la classe doit être complet avec l'espace de noms.

Par exemple, vous pouvez utiliser le code suivant pour définir une propriété de build avec la date du jour.

<Today>$([System.DateTime]::Now.ToString('yyyy.MM.dd'))</Today>

Fonctions de propriété MSBuild

Vous pouvez accéder à plusieurs méthodes statiques dans votre build, qui prennent en charge des fonctions liées à l'arithmétique, à la logique au niveau du bit et aux caractères d'échappement. Pour accéder à ces méthodes, utilisez la syntaxe suivante, où Method est le nom de la méthode et (Parameters) la liste des paramètres pour la méthode.

$([MSBuild]::Method(Parameters))

Par exemple, pour ajouter en même temps deux propriétés qui ont des valeurs numériques, utilisez le code suivant.

$([MSBuild]::Add($(NumberOne), $(NumberTwo)))

Voici une liste de fonctions de propriété MSBuild :

Signature de fonction Description
double Add(double a, double b) Additionne deux doubles.
long Add(long a, long b) Additionne deux longs.
double Subtract(double a, double b) Fait une soustraction entre deux doubles.
long Subtract(long a, long b) Fait une soustraction entre deux longs.
double Multiply(double a, double b) Fait une multiplication de deux doubles.
long Multiply(long a, long b) Fait une multiplication de deux longs.
double Divide(double a, double b) Fait une division de deux doubles.
long Divide(long a, long b) Fait une division de deux longs.
double Modulo(double a, double b) Calcule le modulo de deux doubles.
long Modulo(long a, long b) Calcule le modulo de deux longs.
string Escape(string unescaped) Place un caractère d'échappement devant la chaîne selon les règles d'échappement de MSBuild.
string Unescape(string escaped) Enlève le caractère d'échappement de la chaîne selon les règles d'échappement de MSBuild.
int BitwiseOr(int first, int second) Effectue un OR au niveau du bit sur le premier et le second entier (premier | second).
int BitwiseAnd(int first, int second) Effectue un AND au niveau du bit sur le premier et le second entier (premier & second).
int BitwiseXor(int first, int second) Effectue un XOR au niveau du bit sur le premier et le second entier (premier ^ second).
int BitwiseNot(int first) Effectue un NOT au niveau du bit (~premier).
bool IsOsPlatform(string platformString) Spécifie si la plateforme du système d’exploitation actuelle est platformString. platformStringdoit être membre de OSPlatform.
bool IsOSUnixLike() True si le système d’exploitation actuel est un système Unix.
string NormalizePath(params string[] path) Obtient le chemin complet au format canonique du chemin fourni et vérifie qu’il contient les caractères de séparateur de répertoire appropriés au système d’exploitation actuel.
string NormalizeDirectory(params string[] path) Obtient le chemin complet au format canonique du répertoire fourni et vérifie qu’il contient les caractères de séparateur de répertoire appropriés au système d’exploitation actuel et qu’il se termine par une barre oblique.
string EnsureTrailingSlash(string path) Si le chemin donné ne se termine pas par une barre oblique, ajoutez-en une. Si le chemin est une chaîne vide, ne le modifiez pas.
string GetPathOfFileAbove(string file, string startingDirectory) Recherche et retourne le chemin complet d’un fichier dans la structure de répertoires à et au-dessus de l’emplacement du fichier de build actuel, ou en fonction de startingDirectory, si spécifié.
string GetDirectoryNameOfFileAbove(string startingDirectory, string fileName) Recherche et renvoie le répertoire ou fichier dans le répertoire spécifié ou dans un emplacement de la structure de répertoire au-dessus de ce répertoire.
string MakeRelative(string basePath, string path) Rend path relatif à basePath. basePath doit être un répertoire absolu. Si rendre path relatif n’est pas possible, il est retourné sous forme de chaîne textuelle. Semblable à Uri.MakeRelativeUri.
string ValueOrDefault(string conditionValue, string defaultValue) Retourne la chaîne dans le paramètre defaultValue uniquement si le paramètre conditionValue est vide, sinon, retourne la valeur conditionValue.
string ConvertToBase64(string toEncode) Retourne la chaîne après la conversion de tous les octets en base 64 (caractères alphanumériques plus + et /), se terminant par un ou deux =.
string ConvertFromBase64(string toDecode) Retourne la chaîne après la conversion depuis base 64 (caractères alphanumériques plus + et /), se terminant par un ou deux =.

Fonctions de propriété imbriquées

Vous pouvez combiner des fonctions de propriété pour former des fonctions plus complexes, comme dans l’exemple suivant :

$([MSBuild]::BitwiseAnd(32, $([System.IO.File]::GetAttributes(tempFile))))

Cet exemple retourne la valeur de FileAttributes.Bit Archive (32 ou 0) du fichier donné par le chemin d’accès tempFile. Notez que les valeurs des données énumérées ne peuvent pas apparaître par leur nom dans certains contextes. Dans l’exemple précédent, la valeur numérique (32) doit être utilisée à la place. Dans d’autres cas, selon les attentes de la méthode appelée, la valeur des données d’énumération doit être utilisée. Dans l’exemple suivant, la valeur enum RegexOptions.ECMAScript doit être utilisé, car une valeur numérique ne peut pas être convertie comme prévu par cette méthode.

<PropertyGroup>
    <GitVersionHeightWithOffset>$([System.Text.RegularExpressions.Regex]::Replace("$(PrereleaseVersion)", "^.*?(\d+)$", "$1", "System.Text.RegularExpressions.RegexOptions.ECMAScript"))</GitVersionHeightWithOffset>
</PropertyGroup>

Des métadonnées peuvent également apparaître dans des fonctions de propriété imbriquées. Pour plus d’informations, consultez l’article Batching (Traitement par lot MSBuild).

Fonction MSBuild DoesTaskHostExist

La fonction de propriété DoesTaskHostExist de MSBuild retourne une valeur indiquant si un hôte de tâche est actuellement installé pour les valeurs de runtime et d'architecture spécifiées.

La syntaxe de cette fonction de propriété est la suivante :

$([MSBuild]::DoesTaskHostExist(string theRuntime, string theArchitecture))

MSBuild EnsureTrailingSlash

La fonction de propriété EnsureTrailingSlash dans MSBuild ajoute une barre oblique de fin s’il n’en existe pas déjà une.

La syntaxe de cette fonction de propriété est la suivante :

$([MSBuild]::EnsureTrailingSlash('$(PathProperty)'))

Fonction MSBuild GetDirectoryNameOfFileAbove

La fonction de propriété MSBuild GetDirectoryNameOfFileAbove recherche vers le haut un répertoire contenant le fichier spécifié, en commençant dans (et incluant) le répertoire spécifié. Elle retourne le chemin d’accès complet du répertoire le plus proche contenant le fichier s’il est trouvé, sinon une chaîne vide.

La syntaxe de cette fonction de propriété est la suivante :

$([MSBuild]::GetDirectoryNameOfFileAbove(string startingDirectory, string fileName))

Cet exemple montre comment importer le fichier EnlistmentInfo.props le plus proche dans ou au-dessus du répertoire actif, uniquement si une correspondance est trouvée :

<Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), EnlistmentInfo.props))\EnlistmentInfo.props" Condition=" '$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), EnlistmentInfo.props))' != '' " />

Notez que cet exemple peut être écrit de façon plus concise à l’aide de la fonction GetPathOfFileAbove à la place :

<Import Project="$([MSBuild]::GetPathOfFileAbove(EnlistmentInfo.props))" Condition=" '$([MSBuild]::GetPathOfFileAbove(EnlistmentInfo.props))' != '' " />

MSBuild GetPathOfFileAbove

La fonction de propriété MSBuild GetPathOfFileAbove recherche vers le haut un répertoire contenant le fichier spécifié, en commençant dans (et incluant) le répertoire spécifié. Elle retourne le chemin d’accès complet du fichier correspondant le plus proche s’il est trouvé, sinon une chaîne vide.

La syntaxe de cette fonction de propriété est la suivante :

$([MSBuild]::GetPathOfFileAbove(string file, [string startingDirectory]))

où file est le nom du fichier à rechercher et startingDirectory est un répertoire facultatif dans lequel démarrer la recherche. Par défaut, la recherche démarre dans le répertoire du fichier actif.

Cet exemple montre comment importer un fichier nommé dir.props dans ou au-dessus du répertoire actif, uniquement si une correspondance est trouvée :

<Import Project="$([MSBuild]::GetPathOfFileAbove(dir.props))" Condition=" '$([MSBuild]::GetPathOfFileAbove(dir.props))' != '' " />

ce qui est fonctionnellement équivalent à

<Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" Condition=" '$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))' != '' " />

Toutefois, vous devez parfois démarrer la recherche dans le répertoire parent pour éviter de faire correspondre le fichier actif. Cet exemple montre comment un fichier Directory.Build.props peut importer le fichier Directory.Build.props le plus proche dans un niveau strictement supérieur de l’arborescence, sans s’importer de manière récursive :

<Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />

ce qui est fonctionnellement équivalent à

<Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove('$(MSBuildThisFileDirectory)../', 'Directory.Build.props'))/Directory.Build.props" />

Fonction MSBuild GetRegistryValue

La propriété de fonction MSBuild GetRegistryValue retourne la valeur d'une clé de Registre. Cette fonction prend deux arguments, le nom de la clé et le nom de la valeur, et retourne la valeur qui se trouve dans le Registre. Si vous ne spécifiez pas un nom de valeur, la valeur par défaut est retournée.

Les exemples suivants montrent comment cette fonction est utilisée :

$([MSBuild]::GetRegistryValue(`HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\10.0\Debugger`, ``))                                  // default value
$([MSBuild]::GetRegistryValue(`HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\10.0\Debugger`, `SymbolCacheDir`))
$([MSBuild]::GetRegistryValue(`HKEY_LOCAL_MACHINE\SOFTWARE\(SampleName)`, `(SampleValue)`))             // parens in name and value

Avertissement

Dans la version du SDK .NET de MSBuild (dotnet build), cette fonction n’est pas prise en charge.

Fonction MSBuild GetRegistryValueFromView

La fonction de propriété MSBuild GetRegistryValueFromView extrait des données du Registre système en fonction de la clé de Registre, de la valeur et d'une ou plusieurs vues ordonnées du Registre. La clé et la valeur sont recherchées dans chaque vue du Registre dans l'ordre, jusqu'à ce qu'elles soient trouvées.

Le syntaxe de cette fonction de propriété est :

[MSBuild]::GetRegistryValueFromView(string keyName, string valueName, object defaultValue, params object[] views)

Le système d’exploitation Windows 64 bits gère une clé de Registre HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node qui présente une vue de Registre HKEY_LOCAL_MACHINE\SOFTWARE pour les applications 32 bits.

Par défaut, une application 32 bits s'exécutant sur WOW64 accède à la vue de Registre 32 bits et une application 64 bits accède à la vue de Registre 64 bits.

Les vues de Registre suivantes sont disponibles :

Vue de Registre Définition
RegistryView.Registry32 Vue de Registre pour les applications 32 bits.
RegistryView.Registry64 Vue de Registre pour les applications 64 bits.
RegistryView.Default La vue de Registre qui correspond au processus sur lequel l'application s'exécute.

Voici un exemple.

$([MSBuild]::GetRegistryValueFromView('HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Microsoft SDKs\Silverlight\v3.0\ReferenceAssemblies', 'SLRuntimeInstallPath', null, RegistryView.Registry64, RegistryView.Registry32))

Il extrait les données de SLRuntimeInstallPath de la clé ReferenceAssemblies, en recherchant d’abord dans la vue de Registre 64 bits, puis dans la vue de Registre 32 bits.

Avertissement

Dans la version du SDK .NET de MSBuild (dotnet build), cette fonction n’est pas prise en charge.

Fonction MSBuild MakeRelative

La fonction de propriété MSBuild MakeRelative retourne le chemin d'accès relatif du second chemin par rapport au premier chemin. Chaque chemin peut être un fichier ou un dossier.

La syntaxe de cette fonction de propriété est la suivante :

$([MSBuild]::MakeRelative($(FileOrFolderPath1), $(FileOrFolderPath2)))

Le code suivant est un exemple de cette syntaxe.

<PropertyGroup>
    <Path1>c:\users\</Path1>
    <Path2>c:\users\username\</Path2>
</PropertyGroup>

<Target Name = "Go">
    <Message Text ="$([MSBuild]::MakeRelative($(Path1), $(Path2)))" />
    <Message Text ="$([MSBuild]::MakeRelative($(Path2), $(Path1)))" />
</Target>

<!--
Output:
   username\
   ..\
-->

MSBuild StableStringHash

La fonction de propriété MSBuild StableStringHash accepte un argument de chaîne et retourne un code de hachage garanti stable, ce qui signifie que le même code est toujours retourné pour la même entrée de chaîne. Le hachage retourné est le même, que MSBuild ou dotnet build soit utilisé, et qu’il soit stable dans l’architecture de la plateforme, contrairement à la méthode GetHashCode.NET. Il n’est pas garanti qu’il soit stable entre différentes versions de MSBuild.

Cette fonction est disponible dans MSBuild 16.9.0 ou version ultérieure.

L'exemple suivant montre comment cette fonction est utilisée.

<Project>
   <PropertyGroup>
      <MyHash>$([MSBuild]::StableStringHash("test1"))</MyHash>
   </PropertyGroup>

   <Target Name="WriteHash" AfterTargets="Build">
      <Message Text="Hash: $(MyHash)"/>
   </Target>
</Project>

À partir de la version 17.10.0 de MSBuild, cette fonction accepte un deuxième argument, facultatif, requérant l'algorithme de hachage à utiliser :

<Project>
   <PropertyGroup>
      <MyHash>$([MSBuild]::StableStringHash("test1", "Sha256"))</MyHash>
   </PropertyGroup>

   <Target Name="WriteHash" AfterTargets="Build">
      <Message Text="Hash: $(MyHash)"/>
   </Target>
</Project>

Le deuxième argument est insensible à la casse et supporte actuellement les valeurs suivantes :

  • Legacy – conserve le même comportement qu'en appelant la fonction sans le second argument. Renvoie un entier signé de 32 bits avec des propriétés similaires à celles de string.GetHashCode.
  • Fnv1a32bit - Renvoie un entier signé de 32 bits représentant un hachage Fowler–Noll–Vo hash of version '1a' de la chaîne donnée.
  • Fnv1a64bit - Renvoie un entier signé de 64 bits représentant un hachage Fowler–Noll–Vo hash of version '1a' de la chaîne donnée.
  • Sha256 – Renvoie une chaîne hexadécimale sans préfixe représentant un hachage SHA256 de la chaîne donnée.

Fonction MSBuild ValueOrDefault

La fonction de propriété MSBuild ValueOrDefault retourne le premier argument, sauf s'il est null ou vide. Si le premier argument est null ou vide, la fonction retourne le second argument.

L'exemple suivant montre comment cette fonction est utilisée.

<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

    <PropertyGroup>
        <Value1>$([MSBuild]::ValueOrDefault('$(UndefinedValue)', 'a'))</Value1>
        <Value2>$([MSBuild]::ValueOrDefault('b', '$(Value1)'))</Value2>
    </PropertyGroup>

    <Target Name="MyTarget">
        <Message Text="Value1 = $(Value1)" />
        <Message Text="Value2 = $(Value2)" />
    </Target>
</Project>

<!--
Output:
  Value1 = a
  Value2 = b
-->

Fonctions MSBuild TargetFramework et TargetPlatform

MSBuild 16.7 et versions ultérieures définissent plusieurs fonctions pour gérer les propriétés TargetFramework et TargetPlatform.

Signature de fonction Description
GetTargetFrameworkIdentifier(string targetFramework) Analysez l’objet TargetFrameworkIdentifier à partir du TargetFramework.
GetTargetFrameworkVersion(string targetFramework, int versionPartCount) Analysez targetFrameworkVersion à partir de TargetFramework.
GetTargetPlatformIdentifier(string targetFramework) Analysez l’objet TargetPlatformIdentifier à partir du TargetFramework.
GetTargetPlatformVersion(string targetFramework, int versionPartCount) Analysez targetPlatformVersion à partir du TargetFramework.
IsTargetFrameworkCompatible(string targetFrameworkTarget, string targetFrameworkCandidate) Retournez « True » si la version cible de .Net Framework candidate (deuxième argument) est compatible avec la version cible de .Net Framework indiquée par le premier argument et false dans le cas contraire.

Le paramètre versionPartCount de GetTargetFrameworkVersion et GetTargetPlatformVersion a la valeur par défaut 2.

L’exemple suivant montre comment ces fonctions sont utilisées.

<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

    <PropertyGroup>
        <Value1>$([MSBuild]::GetTargetFrameworkIdentifier('net5.0-windows7.0'))</Value1>
        <Value2>$([MSBuild]::GetTargetFrameworkVersion('net5.0-windows7.0'))</Value2>
        <Value3>$([MSBuild]::GetTargetPlatformIdentifier('net5.0-windows7.0'))</Value3>
        <Value4>$([MSBuild]::GetTargetPlatformVersion('net5.0-windows7.0'))</Value4>
        <Value5>$([MSBuild]::IsTargetFrameworkCompatible('net5.0-windows', 'net5.0'))</Value5>
        <Value6>$([MSBuild]::IsTargetFrameworkCompatible('net5.0', 'net6.0'))</Value6>
        <Value7>$([MSBuild]::IsTargetFrameworkCompatible('net5.0', 'net8.0'))</Value7>
    </PropertyGroup>

    <Target Name="MyTarget">
        <Message Text="Value1 = $(Value1)" />
        <Message Text="Value2 = $(Value2)" />
        <Message Text="Value3 = $(Value3)" />
        <Message Text="Value4 = $(Value4)" />
        <Message Text="Value5 = $(Value5)" />
        <Message Text="Value6 = $(Value6)" />
        <Message Text="Value7 = $(Value7)" />
    </Target>
</Project>

Value1 = .NETCoreApp
Value2 = 5.0
Value3 = windows
Value4 = 7.0
Value5 = True
Value6 = False
Value7 = False

Fonctions de comparaison de versions de MSBuild

MSBuild 16.5 et versions ultérieures définissent plusieurs fonctions pour comparer des chaînes qui représentent des versions.

Notes

Les opérateurs de comparaison dans des conditions peuvent comparer des chaînes qui peuvent être analysées en tant qu’objets System.Version, mais la comparaison peut produire des résultats inattendus. Préférez les fonctions de propriété.

Signature de fonction Description
VersionEquals(string a, string b) Retourne true si les versions a et b sont équivalentes conformément aux règles ci-dessous.
VersionGreaterThan(string a, string b) Retourne true si la version a est supérieure à b selon les règles ci-dessous.
VersionGreaterThanOrEquals(string a, string b) Retourne true si la version a est supérieure ou égale à b selon les règles ci-dessous.
VersionLessThan(string a, string b) Retourne true si la version a est inférieure à b selon les règles ci-dessous.
VersionLessThanOrEquals(string a, string b) Retourne true si la version a est inférieure ou égale à b selon les règles ci-dessous.
VersionNotEquals(string a, string b) Retourne false si les versions a et b sont équivalentes conformément aux règles ci-dessous.

Dans ces méthodes, les versions sont analysées comme System.Version, avec les exceptions suivantes :

  • Le v ou V de début est ignoré, ce qui permet la comparaison avec $(TargetFrameworkVersion).

  • Tout ce qui va du premier « - » ou « + » à la fin de la chaîne de version est ignoré. Cela permet de passer des versions sémantiques (SemVer), bien que l’ordre ne soit pas le même que SemVer. Au lieu de cela, les spécificateurs de préversion et les métadonnées de build n’ont pas de poids pour le tri. Cela peut être utile, par exemple, pour activer une fonctionnalité pour >= x.y et l’activer sur x.y.z-pre.

  • Les parties non spécifiées sont identiques aux parties à valeur zéro. (x == x.0 == x.0.0 == x.0.0.0).

  • L’espace blanc n’est pas autorisé dans les composants entiers.

  • La version principale uniquement est valide (3 est égal à 3.0.0.0)

  • + n’est pas autorisé en tant que composant d’entier signé positif (il est traité comme des métadonnées SemVer et ignoré)

Conseil

Les comparaisons des propriétés TargetFramework doivent généralement utiliser IsTargetFrameworkCompatible au lieu d’extraire et de comparer des versions. Cela permet de comparer des TargetFramework qui varient dans TargetFrameworkIdentifier et dans leur version.

Fonctions de condition MSBuild

Les fonctions Exists et HasTrailingSlash ne sont pas des fonctions de propriété. Elles peuvent être utilisées avec l’attribut Condition. Consultez Conditions MSBuild.

Contenu connexe