Quelles sont les différences entre AssemblyVersion, Assemblyfilversion et AssemblyInformationalVersion?

il y a trois attributs de version d'assemblage. Quelles sont les différences? Est-ce que je peux utiliser AssemblyVersion et ignorer le reste?


MSDN dit:

  • AssemblyVersion :

    spécifie la version de l'assemblage attribué.

  • AssemblyFileVersion :

    demande à un compilateur d'utiliser un numéro de version spécifique pour la ressource de version de fichier Win32. Il n'est pas nécessaire que la version de fichier Win32 soit la même que le numéro de version de l'Assemblée.

  • AssemblyInformationalVersion :

    définit les informations de version supplémentaires pour un manifeste d'assemblage.


il s'agit d'un suivi de quelles sont les meilleures pratiques pour utiliser les attributs D'assemblage?

778
demandé sur Ian Kemp 2008-09-15 20:47:38
la source

7 ответов

AssemblyVersion

où d'autres assemblages qui font référence à votre assemblage regarderont. Si ce numéro change, d'autres assemblées doivent mettre à jour leurs références à votre assemblée! Le AssemblyVersion est requis.

j'utilise le format: majeur.mineur . Il en résulterait:

[assembly: AssemblyVersion("1.0")]

AssemblyFileVersion

utilisé pour le déploiement. Vous pouvez augmenter ce nombre pour chaque déploiement. Il est utilisé par les programmes d'installation. Utilisez-le pour marquer les assemblages qui ont le même AssemblyVersion , mais qui sont générés à partir de différentes constructions.

sous Windows, il peut être consulté dans les propriétés du fichier.

si possible, qu'il soit généré par MSBuild. La version Assemblyfil est optionnelle. Si ce n'est pas le cas, la version Assembly est utilisée.

j'utilise le format: majeur.mineur.révision.construire , où j'utilise la révision pour le stade de développement (Alpha, bêta, RC et RTM), les packs de service et les correctifs. Il en résulterait:

[assembly: AssemblyFileVersion("1.0.3100.1242")]

AssemblyInformationalVersion

la version Produit de l'assemblage. C'est la version que vous utilisez lorsque vous parlez aux clients ou pour l'affichage sur votre site web. Cette version peut être une chaîne, comme ' 1.0 Release Candidate "

l'analyse de Code se plaindra (CA2243) -- rapporté à Microsoft (non corrigé dans VS2013).

le AssemblyInformationalVersion est facultatif. Si elle n'est pas fournie, la version Assemblyfil est utilisée.

j'utilise le format: majeur.mineur [révision à la chaîne] . Il en résulterait:

[assembly: AssemblyInformationalVersion("1.0 RC1")]
830
répondu Rémy van Duijkeren 2018-02-20 21:07:38
la source

Versioning des assemblages dans .NET peut être une perspective confuse étant donné qu'il existe actuellement au moins trois façons de spécifier une version pour votre assemblage.

Voici les trois principaux attributs d'assemblage liés à la version:

// Assembly mscorlib, Version 2.0.0.0
[assembly: AssemblyFileVersion("2.0.50727.3521")]
[assembly: AssemblyInformationalVersion("2.0.50727.3521")]
[assembly: AssemblyVersion("2.0.0.0")]

Par convention, les quatre parties de la version sont appelés les Version Majeure , Version Mineure , Construire , et Révision .

le AssemblyFileVersion est destiné à identifier de façon unique une construction du assemblage individuel

en général, vous définissez manuellement les versions Major et Minor AssemblyFileVersion pour refléter la version de l'assemblage, puis incrémentez La Construction et/ou la révision à chaque fois que votre système de construction compile l'assemblage. Le AssemblyFileVersion devrait vous permettre d'identifier de façon unique une construction de l'Assemblée, pour que vous puissiez l'utiliser comme point de départ pour déboguer tout problème.

sur mon projet actuel, nous avons le serveur de compilation qui code le numéro de liste de modifications de notre dépôt de contrôle source dans les parties de compilation et de révision de la version Assembly. Cela nous permet de mapper directement d'un assemblage à son code source, pour tout assemblage généré par le serveur de compilation (sans avoir à utiliser d'étiquettes ou de branches dans le contrôle source, ou à conserver manuellement des enregistrements de version.)

ce numéro de version est stocké dans la ressource de version de Win32 et peut être vu lors de la visualisation des pages de propriétés de Windows Explorer pour l'assemblage.

Le CLR ne pas s'en soucier, ni examiner les AssemblyFileVersion.

le AssemblyInformationalVersion est destiné à représenter la version de votre produit entier

la Versioninformative Assembly est destinée à permettre versioning cohérent de l'ensemble du produit, qui peut consister en de nombreuses assemblées qui sont indépendamment versioned, peut-être avec des politiques de versioning différentes, et potentiellement développé par des équipes disparates.

"Par exemple, la version 2.0 d'un produit peut contenir plusieurs assemblées; un de ces assemblées est marqué comme version 1.0 puisqu'il s'agit d'un nouvel assemblage qui n'a pas été envoyé dans la version 1.0 du même produit. En règle générale, vous définissez la grands et parties mineures de cette version nombre représentant la version publique de votre produit. Ensuite, vous incrémentez les parties de construction et de révision à chaque fois vous emballez un produit complet avec toutes ses assemblées." - Jeffrey Richter, [CLR via C# (Second Edition)] p. 57

le CLR ne se soucie pas de la version "Assemblyinformational" et ne l'examine pas.

Le AssemblyVersion est la seule version du CLR se soucie (mais il se soucie de l'ensemble AssemblyVersion )

la version Assembly est utilisée par le CLR pour se lier à des assemblages fortement nommés. Il est stocké dans la table des métadonnées manifestes AssemblyDef de l'assemblage construit, et dans la table AssemblyRef de tout assemblage qui le fait référence.

c'est très important, parce que cela signifie que lorsque vous faites référence à un assemblage fortement nommé, vous êtes étroitement lié à une version Assemblée spécifique de cet assemblage. Toute la Versionassemblée doit correspondre exactement à la reliure pour réussir. Par exemple, si vous faites référence à la version 1.0.0.0 d'un assemblage fortement nommé au moment de la construction, mais que seule la version 1.0.0.1 de cet assemblage est disponible au moment de l'exécution, la liaison échouera! (Vous devrez alors contourner ce problème en utilisant Assembly Binding Redirection .)

Confusion quant à savoir si la totalité du AssemblyVersion doit correspondre. (Oui, c'est fait.)

Il y a une petite confusion sur le fait de savoir si toute la version assembly doit être une correspondance exacte pour qu'un assemblage soit chargé. Certaines personnes sont sous la fausse croyance que seules les parties majeures et mineures de la version Assembly doivent concorder pour que la liaison réussisse. Il s'agit d'une hypothèse raisonnable, mais elle est en fin de compte incorrecte (à partir de .net 3.5), et il est trivial de vérifier cela pour votre version du CLR. Il suffit d'exécuter ce code d'exemple .

sur ma machine, la seconde charge de montage tombe en panne, et les deux dernières lignes du journal de fusion indiquent clairement pourquoi:

.NET Framework Version: 2.0.50727.3521
---
Attempting to load assembly: Rhino.Mocks, Version=3.5.0.1337, Culture=neutral, PublicKeyToken=0b3305902db7183f
Successfully loaded assembly: Rhino.Mocks, Version=3.5.0.1337, Culture=neutral, PublicKeyToken=0b3305902db7183f
---
Attempting to load assembly: Rhino.Mocks, Version=3.5.0.1336, Culture=neutral, PublicKeyToken=0b3305902db7183f
Assembly binding for  failed:
System.IO.FileLoadException: Could not load file or assembly 'Rhino.Mocks, Version=3.5.0.1336, Culture=neutral, 
PublicKeyToken=0b3305902db7183f' or one of its dependencies. The located assembly's manifest definition 
does not match the assembly reference. (Exception from HRESULT: 0x80131040)
File name: 'Rhino.Mocks, Version=3.5.0.1336, Culture=neutral, PublicKeyToken=0b3305902db7183f'

=== Pre-bind state information ===
LOG: User = Phoenix\Dani
LOG: DisplayName = Rhino.Mocks, Version=3.5.0.1336, Culture=neutral, PublicKeyToken=0b3305902db7183f
 (Fully-specified)
LOG: Appbase = [...]
LOG: Initial PrivatePath = NULL
Calling assembly : AssemblyBinding, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null.
===
LOG: This bind starts in default load context.
LOG: No application configuration file found.
LOG: Using machine configuration file from C:\Windows\Microsoft.NET\Framework64\v2.0.50727\config\machine.config.
LOG: Post-policy reference: Rhino.Mocks, Version=3.5.0.1336, Culture=neutral, PublicKeyToken=0b3305902db7183f
LOG: Attempting download of new URL [...].
WRN: Comparing the assembly name resulted in the mismatch: Revision Number
ERR: Failed to complete setup of assembly (hr = 0x80131040). Probing terminated.

je pense que la source de cette confusion est probablement parce que Microsoft avait à l'origine l'intention d'être un peu plus indulgente sur cette correspondance stricte de la version Assembly complète, en ne faisant concorder que sur les versions majeures et mineures:

" lors du chargement d'un ensemble, le CLR trouvera automatiquement la dernière version d'entretien installée qui correspond à la version major / minor De La l'assemblée de la demande." - Jeffrey Richter, [CLR via C# (Second Edition)] p. 56

c'était le comportement dans la Bêta 1 du CLR 1.0, mais cette fonctionnalité a été supprimée avant la version 1.0, et n'a pas réussi à refaire surface dans .NET 2.0:

"Note: je viens de décrire comment vous pensez aux numéros de version. Malheureusement, le CLR ne traite pas les numéros de version de cette façon. [In .NET 2.0], le CLR traite un numéro de version comme une valeur opaque, et si un assemblage dépend de la version 1.2.3.4 d'une autre montage, le CLR essaie de charger version 1.2.3.4 seulement (à moins qu'une la redirection est en place). Cependant, Microsoft a des plans pour changer le Le chargeur de CLR dans une version future donc qu'il se charge de la dernière version/révision pour un majeur/mineur version d'un assemblage . Exemple, sur une version future du CLR, si le chargeur essaie de trouver la version 1.2.3.4 d'une assemblée et la version 1.2.5.0 existe, le chargeur avec automatiquement ramasser la dernière version d'entretien. Ce sera un très changement bienvenu dans le chargeur du CLR-I pour l'un ne peut pas attendre." - Jeffrey Richter, [CLR via C# (Second Edition)] p. 164 (non souligné dans l'original) le mien)

comme ce changement n'a pas encore été mis en œuvre, je pense qu'il est supposons que Microsoft avait revenue sur cette intention, et c'est peut-être trop tard pour changer maintenant. J'ai essayé de chercher sur le web pour trouver ce qui s'est passé avec ces plans, mais je n'ai pas pu trouver de réponses. Je voulais quand même aller au fond des choses.

alors J'ai envoyé un e - mail à Jeff Richter et je lui ai demandé directement-j'ai pensé que si quelqu'un savait ce qui s'était passé, ce serait lui.

il a répondu dans les 12 heures, un samedi matin pas moins, et a précisé que le chargeur. net 1.0 Beta 1 a mis en œuvre ce mécanisme de "roll-forward automatique" pour récupérer la dernière version disponible de la construction et de la révision d'un assemblage, mais ce comportement a été inversé avant la livraison de.net 1.0. Il a été prévu plus tard pour ranimer ce, mais il n'a pas fait avant que le CLR 2.0 embarqué. Puis vint Silverlight, qui a pris la priorité pour L'équipe CLR, de sorte que cette fonctionnalité a été retardée davantage. Entre-temps, la plupart des gens qui étaient autour dans les jours de CLR 1.0 Beta 1 ont depuis on est passé à autre chose, donc il est peu probable que cela voie le jour, malgré tout le travail qui a déjà été mis en place.

Le comportement actuel, il semble, est là pour rester.

il est également intéressant de noter à partir de ma discussion avec Jeff que AssemblyFileVersion N'a été ajouté qu'après la suppression du mécanisme de "roll-forward automatique" - parce qu'après 1.0 Beta 1, tout changement à la AssemblyVersion était un changement de rupture pour vos clients, il y avait puis nulle part pour stocker en toute sécurité votre numéro de construction. AssemblyFileVersion est ce refuge, car il n'est jamais automatiquement examiné par le CLR. Peut-être que c'est plus clair de cette façon, d'avoir deux numéros de version séparés, avec des significations séparées, plutôt que d'essayer de faire cette séparation entre les parties Major/Minor (casser) et Build/Revision (non-casser) de la version Assembly.

La ligne du bas: Réfléchir soigneusement lorsque vous modifiez votre AssemblyVersion

la morale est que si vous envoyez des assemblages que d'autres développeurs vont référencer, vous devez être extrêmement prudent lorsque vous changez (et ne changez pas) la version assembly de ces assemblages. Toute modification apportée à la directive AssemblyVersion signifie que les développeurs d'applications devront soit se recompiler contre la nouvelle version (pour mettre à jour les entrées AssemblyRef), soit utiliser des redirections assembly binding pour outrepasser manuellement la nouvelle version.

  • ne pas changer la version Assembly pour une version d'entretien qui est destinée à être rétrocompatible.
  • Do changez la version Assembly pour une version dont vous savez qu'elle a des changements de rupture.

il suffit de jeter un autre coup d'oeil aux attributs de version sur mscorlib:

// Assembly mscorlib, Version 2.0.0.0
[assembly: AssemblyFileVersion("2.0.50727.3521")]
[assembly: AssemblyInformationalVersion("2.0.50727.3521")]
[assembly: AssemblyVersion("2.0.0.0")]

notez que C'est la version assembly qui contient tous les services intéressants information (C'est la partie révision de cette version qui vous indique sur quel Service Pack vous êtes), pendant ce temps la version Assembly est fixée à un vieux 2.0.0.0 ennuyeux. Toute modification de la version Assembly forcerait chaque application .NET référencant mscorlib.dll pour recompiler contre la nouvelle version!

544
répondu Daniel Fortunov 2018-06-06 21:06:33
la source

AssemblyVersion reste à peu près à l'intérieur de .NET, tandis que AssemblyFileVersion est ce que Windows voit. Si vous allez dans les propriétés d'une assemblée située dans un répertoire et que vous passez à l'onglet version, le AssemblyFileVersion est ce que vous verrez en haut. Si vous triez des fichiers par version, C'est ce qui est utilisé par L'Explorateur.

le AssemblyInformationalVersion correspond à la "version produit"et est destiné à être purement "utilisé par l'homme".

AssemblyVersion est certainement le plus important, mais je ne sauterais pas non plus AssemblyFileVersion . Si vous ne fournissez pas AssemblyInformationalVersion , le compilateur l'ajoute pour vous en enlevant la partie "révision" de votre numéro de version et en laissant la majuscule.mineur.construire.

39
répondu Bob King 2015-04-11 00:33:15
la source

AssemblyInformationalVersion et AssemblyFileVersion sont affichés lorsque vous affichez la "Version" de l'information sur un fichier via l'Explorateur Windows en affichant les propriétés du fichier. Ces attributs sont compilés dans une ressource VERSION_INFO créée par le compilateur.

AssemblyInformationalVersion est la valeur de la "version du produit". AssemblyFileVersion est la valeur" File version".

le AssemblyVersion est spécifique aux assemblages .NET et est utilisé par L'assemblage .NET chargeur pour savoir quelle version d'un ensemble charger/lier à l'exécution.

parmi ceux-ci, le seul qui est absolument requis par .NET est l'attribut AssemblyVersion . Malheureusement, il peut aussi causer le plus de problèmes quand il change sans discernement, surtout si vous êtes fort en nommant vos assemblées.

21
répondu Scott Dorman 2018-01-24 03:08:33
la source

il est intéressant de noter d'autres choses:

1) comme indiqué dans la boîte de dialogue Propriétés de Windows Explorer pour le fichier assembly généré, il y a deux endroits appelés "File version". Celui qui apparaît dans l'en-tête du dialogue affiche la version Assembly, pas la version AssemblyFileVersion.

dans la section"information sur les autres versions", il y a un autre élément appelé "File Version". C'est là que vous pouvez voir ce qui a été entré en tant que AssemblyFileVersion.

2) AssemblyFileVersion est juste du texte brut. Il n'a pas à se conformer aux restrictions du schéma de numérotation que fait AssemblyVersion ( < 65K, par exemple). Il peut être 3.2..< datetime>, si vous voulez. Votre système de construction devra remplir les jetons.

de plus, il n'est pas soumis au remplacement de Joker Qu'est AssemblyVersion. Si vous avez juste une valeur de " 3.0.1.*" dans le AssemblyInfo.cs, c'est exactement ce que va montrer dans l'élément "autres informations sur la version - > Version du fichier".

3) Je ne sais pas l'impact sur un installateur d'utiliser autre chose que des numéros de version de fichier numérique, cependant.

7
répondu DavidM 2014-02-21 14:40:44
la source

pour garder cette question à jour, il est utile de souligner que AssemblyInformationalVersion est utilisé par NuGet et reflète la version paquet y compris tout suffixe pré-publication.

par exemple une version Assemblée de 1.0.3.* emballé avec le asp.net noyau dotnet-cli

dotnet pack --version-suffix ci-7 src/MyProject

produit un paquet avec la version 1.0.3-ci-7 que vous pouvez inspecter avec réflexion en utilisant:

CustomAttributeExtensions.GetCustomAttribute<AssemblyInformationalVersionAttribute>(asm);
6
répondu KCD 2016-06-23 07:51:15
la source

lorsque la version Assemblée d'un assemblage est modifiée, S'il a un nom fort, les assemblages de référencement doivent être recompilés, sinon l'assemblage ne se charge pas! S'il n'a pas de nom fort, s'il n'a pas été ajouté explicitement au dossier de projet, il ne sera pas copié dans le dossier de sortie lors de la compilation, donc vous pouvez rater les assemblages, surtout après avoir nettoyé le dossier de sortie.

2
répondu linquize 2012-02-17 09:21:50
la source

Autres questions sur .net attributes assemblies