¿Cómo sincronizar la versión de publicación a la versión de ensamblaje en una aplicación .NET ClickOnce?

Question

En mi aplicación C# ClickOnce, hay una versión de publicación autoincrementada en el Proyecto ->Propiedades ->Publicación pestaña. Me gustaría mostrar esa versión en mi menú Ayuda ->Acerca de cuadro, pero el código que estoy usando aparentemente accede a la versión del conjunto, que es diferente.

La versión de ensamblado se puede cambiar manualmente en el Proyecto -> Propiedades -> de aplicación -> diálogo Información de ensamblado. Así que por ahora, cada vez antes de publicar he estado copiando la versión de publicación a la versión de ensamblaje, por lo que mi cuadro de diálogo muestra la versión actual de de la aplicación. Debe haber una mejor manera de hacer esto.

Todo lo que realmente quiero hacer es tener un número de versión preciso, actualizado automáticamente y accesible por código.

Aquí está el código que estoy usando para acceder al número de versión del ensamblado:

public string AssemblyVersion 
{ 
    get 
    { 
     return Assembly.GetExecutingAssembly().GetName().Version.ToString(); 
    } 
} 

Una alternativa sería la de encontrar el código que tiene acceso a la versión publicar.

Answer 1

de Sylvanaar parece que el camino a seguir, en mi experiencia; pero con la advertencia de que solo está disponible para las versiones implementadas de la aplicación. Para propósitos de depuración, es posible que desee algo como:

static internal string GetVersion() 
    { 
     if (ApplicationDeployment.IsNetworkDeployed) 
     { 
      return ApplicationDeployment.CurrentDeployment.CurrentVersion.ToString(); 
     } 

     return "Debug"; 
    } 

Answer 2

Modifiqué mi archivo .csproj para actualizar la versión de ensamblaje. Creé una configuración llamada "Publicación pública" para esto, pero no es necesario para hacer eso.

<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> 
    <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
     Other similar extension points exist, see Microsoft.Common.targets. 
    <Target Name="BeforeBuild"> 
    </Target> 
    <Target Name="AfterBuild"> 
    </Target> 
    --> 
    <PropertyGroup Condition="'$(BuildingInsideVisualStudio)' == 'true'"> 
    <MSBuildCommunityTasksPath>$(SolutionDir)Tools\MSBuildCommunityTasks</MSBuildCommunityTasksPath> 
    </PropertyGroup> 
    <!-- Required Import to use MSBuild Community Tasks --> 
    <Import Project="$(SolutionDir)Tools\MSBuildCommunityTasks\MSBuild.Community.Tasks.Targets" Condition="'$(BuildingInsideVisualStudio)' == 'true'" /> 
    <Target Name="BeforeCompile" Condition="'$(BuildingInsideVisualStudio)|$(Configuration)' == 'true|PublicRelease'"> 
    <FormatVersion Version="$(ApplicationVersion)" Revision="$(ApplicationRevision)"> 
     <Output TaskParameter="OutputVersion" PropertyName="AssemblyVersionToUse" /> 
    </FormatVersion> 
    <AssemblyInfo CodeLanguage="CS" OutputFile="$(ProjectDir)Properties\VersionInfo.cs" AssemblyVersion="$(AssemblyVersionToUse)" AssemblyFileVersion="$(AssemblyVersionToUse)" /> 
    </Target> 

La versión publicada puede ser: última línea

ApplicationDeployment.CurrentDeployment.CurrentVersion 

Answer 3

modifiqué solución de Sylvanaar para su uso con VB:

- Microsoft.VisualBasic.targets instead of Microsoft.CSharp.targets 
- CodeLanguage="VB" instead of CodeLanguage="CS" 
- AssemblyInfo.vb instead of VersionInfo.cs 

, las diferencias en los caminos:

- $(SolutionDir).build instead of $(SolutionDir)Tools\MSBuildCommunityTasks 
- $(ProjectDir)AssemblyInfo.vb instead of $(ProjectDir)Properties\VersionInfo.cs 

, y para eliminar las condiciones :

- Condition="'$(BuildingInsideVisualStudio)' == 'true'" 
- Condition="'$(BuildingInsideVisualStudio)|$(Configuration)' == 'true|PublicRelease'" 

También sincronizado de la empresa y del producto con ClickOnce PublisherName y ProductName, respectivamente, y generó un autor en base a la fecha actual:

- AssemblyCompany="$(PublisherName)" 
- AssemblyProduct="$(ProductName)" 
- AssemblyCopyright="© $([System.DateTime]::Now.ToString(`yyyy`)) $(PublisherName)" 

terminé añadir esto a mi archivo vbproj. Requiere el paquete MSBuildTasks NuGet que se instala por primera vez:

<Import Project="$(MSBuildBinPath)\Microsoft.VisualBasic.targets" /> 
    <PropertyGroup Condition="'$(BuildingInsideVisualStudio)' == 'true'"> 
    <MSBuildCommunityTasksPath>$(SolutionDir).build</MSBuildCommunityTasksPath> 
    </PropertyGroup> 
    <Import Project="$(MSBuildCommunityTasksPath)\MSBuild.Community.Tasks.Targets" Condition="'$(BuildingInsideVisualStudio)' == 'true'" /> 
    <Target Name="BeforeCompile"> 
    <FormatVersion Version="$(ApplicationVersion)" Revision="$(ApplicationRevision)"> 
     <Output TaskParameter="OutputVersion" PropertyName="AssemblyVersionToUse" /> 
    </FormatVersion> 
    <AssemblyInfo CodeLanguage="VB" OutputFile="$(ProjectDir)AssemblyInfo.vb" AssemblyVersion="$(AssemblyVersionToUse)" AssemblyFileVersion="$(AssemblyVersionToUse)" AssemblyCompany="$(PublisherName)" AssemblyProduct="$(ProductName)" AssemblyCopyright="© $([System.DateTime]::Now.ToString(`yyyy`)) $(PublisherName)"/> 
    </Target> 

No estoy seguro de cuánto la ubicación dentro de los asuntos archivo de proyecto, pero he añadido esto al final de mi archivo de proyecto, justo antes:

</Project> 

Answer 4

Lo hice al revés, usé un comodín para mi versión de ensamblaje - 1.0.* - por lo que Visual Studio/MSBuild genera un número de versión de forma automática:

// AssemblyInfo.cs  
[assembly: AssemblyVersion("1.0.*")] 

Y luego añade el siguiente objetivo AfterCompile al proyecto de ClickOnce para asignar PublishVersion sincronizar con la versión de montaje:

<Target Name="AfterCompile"> 
    <GetAssemblyIdentity AssemblyFiles="$(IntermediateOutputPath)$(TargetFileName)"> 
     <Output TaskParameter="Assemblies" ItemName="TargetAssemblyIdentity" /> 
    </GetAssemblyIdentity> 
    <PropertyGroup> 
     <PublishVersion>%(TargetAssemblyIdentity.Version)</PublishVersion> 
    </PropertyGroup> 
</Target> 

Answer 5

lo haría me gusta expandir la respuesta de Sylvanaar, ya que algunos de los detalles de implementación no fueron obvios para mí. Por lo tanto:

1. instalar manualmente las tareas de construir una comunidad que se encuentran en: https://github.com/loresoft/msbuildtasks/releases Nota: No instale por Nuget si se limpia sus paquetes, ya que la construcción fallará antes de tener la oportunidad de restaurar los paquetes, ya que se hace referencia a msbuildtasks como una tarea en el archivo de compilación. Pon todos ellos en la carpeta junto al archivo de solución llamada .build

2. Añadir un archivo completamente vacío a sus proyectos propiedades carpeta llamada VersionInfo.cs

3 eliminar estas líneas si existen en AssemblyInfo.cs

[assembly: AssemblyVersion("1.0.*")] 
[assembly: AssemblyFileVersion("1.0.*")] 

4 Modificar el archivo de csproj

<!-- Include the build rules for a C# project. --> 
    <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" /> 

    <!--INSERT STARTS HERE--> 
    <!--note the use of .build directory--> 
    <PropertyGroup Condition="'$(BuildingInsideVisualStudio)' == 'true'"> 
    <MSBuildCommunityTasksPath>$(SolutionDir)\.build\MSBuildCommunityTasks</MSBuildCommunityTasksPath> 
    </PropertyGroup> 
    <!-- Required Import to use MSBuild Community Tasks --> 
    <Import Project="$(SolutionDir)\.build\MSBuild.Community.Tasks.targets" Condition="'$(BuildingInsideVisualStudio)' == 'true'" /> 
    <Target Name="BeforeCompile" Condition="'$(BuildingInsideVisualStudio)|$(Configuration)' == 'true|Release'"> 
    <FormatVersion Version="$(ApplicationVersion)" Revision="$(ApplicationRevision)"> 
     <Output TaskParameter="OutputVersion" PropertyName="AssemblyVersionToUse" /> 
    </FormatVersion> 
    <AssemblyInfo CodeLanguage="CS" OutputFile="$(ProjectDir)Properties\VersionInfo.cs" AssemblyVersion="$(AssemblyVersionToUse)" AssemblyFileVersion="$(AssemblyVersionToUse)" /> 
    </Target> 

5 Use un método como el siguiente para acceder al texto de la versión:

public string Version 
    { 
     Version version = null; 

     if (ApplicationDeployment.IsNetworkDeployed) 
     { 
      version = ApplicationDeployment.CurrentDeployment.CurrentVersion; 
     } 
     else 
     { 
      version = typeof(ThisAddIn).Assembly.GetName().Version; 
     } 

     return version.ToString(); 
    }