clickonce - forzar - crear actualizaciones c#

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

Question

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

La Versión de ensamblaje se puede cambiar manualmente en el cuadro de diálogo Proyecto -> Propiedades -> Aplicación -> Información de ensamblaje. Por ahora, cada vez que publico, he estado copiando la versión de publicación a la versión de ensamblaje, así que mi cuadro de diálogo muestra la versión actual 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 ensamblaje:

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

Una alternativa sería encontrar el código que accede a la versión de publicación.

Answer 1

La última línea de sylvanaar parece ser 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 fines 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

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

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

Y luego agregué el siguiente objetivo de AfterCompile al proyecto ClickOnce para asignar sincronizar PublishVersion con la versión de ensamblaje:

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

Answer 3

Me gustaría ampliar la respuesta de Sylvanaar, ya que algunos de los detalles de la implementación no eran obvios para mí. Asi que:

1. Instale manualmente las tareas de compilación de la comunidad que se encuentran en: https://github.com/loresoft/msbuildtasks/releases Nota: No instale por nuget si limpia sus paquetes, ya que la compilació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. Los puse en la carpeta junto al archivo de solución llamado .build

2. Agregue un archivo completamente vacío a su carpeta de propiedades de proyectos llamada VersionInfo.cs

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

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

4 Modificar su archivo 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 Utilice 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();
    }

Answer 4

Modifiqué la solución de sylvanaar para usar con VB:

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

, diferencias en caminos:

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

, y para eliminar condiciones:

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

También sincronicé Empresa y Producto con ClickOnce PublisherName y ProductName respectivamente y generé un Copyright basado en la fecha actual:

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

Terminé agregando esto a mi archivo vbproj. Requiere que el paquete de MSBuildTasks NuGet se instale primero:

  <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 importa la ubicación dentro del archivo de proyecto, pero agregué esto al final de mi archivo de proyecto, justo antes:

</Project>

Answer 5

Modifiqué mi archivo .csproj para actualizar la versión de ensamblaje. Creé una configuración llamada "Public Release" para esto, pero no es obligatorio hacerlo.

  <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:

ApplicationDeployment.CurrentDeployment.CurrentVersion