¿Integre automáticamente la "versión mínima requerida" en una implementación de ClickOnce?

Question

¿Hay alguna manera de incrementar automáticamente los campos de "versión mínima requerida" en una implementación de ClickOnce para igualar siempre el número de compilación actual? Básicamente, siempre quiero que mi implementación se actualice automáticamente en el momento del lanzamiento.

Sospecho que voy a necesitar algunos eventos previos o posteriores a la construcción, pero espero que haya una manera más fácil.

Answer 1

Puedo llegar un poco tarde para contestar esta, pero me resultó difícil encontrar la solución en google, pero finalmente lo descubrí, así que pensé en compartirlo.

Con MSBuild versión 4 (VS2010 y VS2012) esto se puede lograr mediante la inserción de la siguiente objetivo:

<Target Name="AutoSetMinimumRequiredVersion" BeforeTargets="GenerateDeploymentManifest"> 
    <FormatVersion Version="$(ApplicationVersion)" Revision="$(ApplicationRevision)"> 
     <Output PropertyName="MinimumRequiredVersion" TaskParameter="OutputVersion" /> 
    </FormatVersion> 
    <FormatVersion Version="$(ApplicationVersion)" Revision="$(ApplicationRevision)"> 
     <Output PropertyName="_DeploymentBuiltMinimumRequiredVersion" TaskParameter="OutputVersion" /> 
    </FormatVersion> 
    </Target> 

El $ (ApplicationVersion) es la misma configuración que puede establecer manualmente en publicar la ventana del proyecto en el VS IDE, con la parte de revisión configurada en un asterisco. $ (ApplicationRevision) es la revisión real que se utiliza para la versión publicada. La tarea FormatVersion es una tarea incorporada de MSBuild que formatea los dos en un único número de versión completa.

Esto configurará la 'Versión mínima requerida' para que sea la misma que la 'Versión de publicación', asegurando así que la nueva implementación siempre será instalada por los usuarios, es decir, no hay opción de Omitir la actualización.

Por supuesto, si no desea establecer la versión mínima requerida para la versión de publicación y desea utilizar una propiedad de origen diferente, entonces es sencillo modificar el objetivo, pero el principio es el mismo.

Answer 2

¿Está buscando actualizaciones de la aplicación?

Hacer clic con el botón derecho en el proyecto en el Explorador de soluciones y luego hacer clic en Publicar ... es la forma incorrecta de obtener actualizaciones de la aplicación. Tienes que hacer clic derecho en tu proyecto y hacer clic en Propiedades, luego hacer clic en la pestaña Publicar. Haga clic en el botón Actualizaciones ... y luego marque la casilla de verificación "La aplicación debe verificar si hay actualizaciones". Allí también puede especificar una versión mínima requerida para la aplicación. (No he usado esa funcionalidad pero la funcionalidad de Actualizaciones es la razón principal por la que uso ClickOnce y funciona muy bien)

Answer 3

Fuera de la caja, no creo que haya una manera. Sin embargo, no es demasiado esfuerzo girar el tuyo.

El método que utilizo es el siguiente:

1) cree un archivo

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> 
    <PropertyGroup> 
    <Util-VersionMajor>1</Util-VersionMajor> 
    <Util-VersionMinor>11</Util-VersionMinor> 
    <Util-VersionBuild>25</Util-VersionBuild> 
    <Util-VersionRevision>0</Util-VersionRevision> 
    <Util-VersionDots>$(Util-VersionMajor).$(Util-VersionMinor).$(Util-VersionBuild).$(Util-VersionRevision)</Util-VersionDots> 
    <Util-VersionUnders>$(Util-VersionMajor)_$(Util-VersionMinor)_$(Util-VersionBuild)_$(Util-VersionRevision)</Util-VersionUnders> 
    <MinimumRequiredVersion>$(Util-VersionDots)</MinimumRequiredVersion> 
    <ApplicationVersion>$(Util-VersionDots)</ApplicationVersion> 
    <ApplicationRevision>$(Util-VersionRevision)</ApplicationRevision> 
    </PropertyGroup> 
</Project> 

2) importar el archivo Version.Properties en los archivos del proyecto a Version.Properties

3) Crear una tarea para incrementar la versión en Build. Esta es la mía

<Target Name="IncrementVersion" DependsOnTargets="Build" Condition="'$(BuildingInsideVisualStudio)'==''"> 
    <ItemGroup> 
     <Util-VersionProjectFileItem Include="$(Util-VersionProjectFile)" /> 
    </ItemGroup> 
    <PropertyGroup> 
     <Util-VersionProjectFileFullPath>@(Util-VersionProjectFileItem->'%(FullPath)')</Util-VersionProjectFileFullPath> 
    </PropertyGroup> 
    <Exec Command="&quot;$(TfCommand)&quot; get /overwrite /force /noprompt &quot;$(Util-VersionProjectFileFullPath)&quot;" Outputs="" /> 
    <Exec Command="&quot;$(TfCommand)&quot; checkout /lock:checkout &quot;$(Util-VersionProjectFileFullPath)&quot;" Outputs="" /> 
    <Version Major="$(Util-VersionMajor)" Minor="$(Util-VersionMinor)" Build="$(Util-VersionBuild)" Revision="$(Util-VersionRevision)" RevisionType="None" BuildType="Increment"> 
     <Output TaskParameter="Major" PropertyName="Util-VersionMajor" /> 
     <Output TaskParameter="Minor" PropertyName="Util-VersionMinor" /> 
     <Output TaskParameter="Build" PropertyName="Util-VersionBuild" /> 
     <Output TaskParameter="Revision" PropertyName="Util-VersionRevision" /> 
    </Version> 
    <XmlUpdate Prefix="msb" Namespace="http://schemas.microsoft.com/developer/msbuild/2003" XPath="/msb:Project/msb:PropertyGroup/msb:Util-VersionMajor" XmlFileName="$(Util-VersionProjectFile)" Value="$(Util-VersionMajor)" /> 
    <XmlUpdate Prefix="msb" Namespace="http://schemas.microsoft.com/developer/msbuild/2003" XPath="/msb:Project/msb:PropertyGroup/msb:Util-VersionMinor" XmlFileName="$(Util-VersionProjectFile)" Value="$(Util-VersionMinor)" /> 
    <XmlUpdate Prefix="msb" Namespace="http://schemas.microsoft.com/developer/msbuild/2003" XPath="/msb:Project/msb:PropertyGroup/msb:Util-VersionBuild" XmlFileName="$(Util-VersionProjectFile)" Value="$(Util-VersionBuild)" /> 
    <XmlUpdate Prefix="msb" Namespace="http://schemas.microsoft.com/developer/msbuild/2003" XPath="/msb:Project/msb:PropertyGroup/msb:Util-VersionRevision" XmlFileName="$(Util-VersionProjectFile)" Value="$(Util-VersionRevision)" /> 
    <Exec Command="&quot;$(TfCommand)&quot; checkin /override:AutoBuildIncrement /comment:***NO_CI*** &quot;$(Util-VersionProjectFileFullPath)&quot;" /> 
    <Exec Command="&quot;$(TfCommand)&quot; get /overwrite /force /noprompt &quot;$(Util-AssemblyInfoFile)&quot;" Outputs="" /> 
    <Exec Command="&quot;$(TfCommand)&quot; checkout /lock:checkout &quot;$(Util-AssemblyInfoFile)&quot;" Outputs="" /> 
    <AssemblyInfo CodeLanguage="CS" OutputFile="$(Util-AssemblyInfoFile)" AssemblyConfiguration="$(Configuration)" AssemblyVersion="$(Util-VersionMajor).$(Util-VersionMinor).$(Util-VersionBuild).$(Util-VersionRevision)" AssemblyFileVersion="$(Util-VersionMajor).$(Util-VersionMinor).$(Util-VersionBuild).$(Util-VersionRevision)" /> 
    <Exec Command="&quot;$(TfCommand)&quot; checkin /override:AutoBuildIncrement /comment:***NO_CI*** &quot;$(Util-AssemblyInfoFile)&quot;" /> 
    </Target> 

Algunos trucos adicionales ClickOnce aquí http://weblogs.asp.net/sweinstein/archive/2008/08/24/top-5-secrets-of-net-desktop-deployment-wizards.aspx

Answer 4

acabé rodando en realidad un complemento a VS que sincroniza todos los números de versión, y luego construye y publica con un solo clic. Fue bastante fácil.

Public Sub Publish() 
     Try 
      Dim startProjName As String = Nothing 
      Dim targetProj As Project = Nothing 
      Dim soln As Solution2 = TryCast(Me._applicationObject.DTE.Solution, Solution2) 
      If soln IsNot Nothing Then 
       For Each prop As [Property] In soln.Properties 
        If prop.Name = "StartupProject" Then 
         startProjName = prop.Value.ToString() 
         Exit For 
        End If 
       Next 
       If startProjName IsNot Nothing Then 
        For Each proj As Project In soln.Projects 
         If proj.Name = startProjName Then 
          targetProj = proj 
          Exit For 
         End If 
        Next 
        If targetProj IsNot Nothing Then 
         Dim currAssemVersionString As String = targetProj.Properties.Item("AssemblyVersion").Value.ToString 
         Dim currAssemVer As New Version(currAssemVersionString) 
         Dim newAssemVer As New Version(currAssemVer.Major, currAssemVer.Minor, currAssemVer.Build, currAssemVer.Revision + 1) 
         targetProj.Properties.Item("AssemblyVersion").Value = newAssemVer.ToString() 
         targetProj.Properties.Item("AssemblyFileVersion").Value = newAssemVer.ToString() 
         Dim publishProps As Properties = TryCast(targetProj.Properties.Item("Publish").Value, Properties) 
         Dim shouldPublish As Boolean = False 
         If publishProps IsNot Nothing Then 
          shouldPublish = CBool(publishProps.Item("Install").Value) 
          If shouldPublish Then 
           targetProj.Properties.Item("GenerateManifests").Value = "true" 
           publishProps.Item("ApplicationVersion").Value = newAssemVer.ToString() 
           publishProps.Item("MinimumRequiredVersion").Value = newAssemVer.ToString() 
           publishProps.Item("ApplicationRevision").Value = newAssemVer.Revision.ToString() 
          End If 
         End If 
         targetProj.Save() 
         Dim build As SolutionBuild2 = TryCast(soln.SolutionBuild, SolutionBuild2) 
         If build IsNot Nothing Then 
          build.Clean(True) 
          build.Build(True) 
          If shouldPublish Then 
           If build.LastBuildInfo = 0 Then 

            build.Publish(True) 
           End If 
          End If 
         End If 
        End If 
       End If 
      End If 
     Catch ex As Exception 
      MsgBox(ex.ToString) 
     End Try 
    End Sub 

Answer 5

Así es como manejé este. En primer lugar he creado una tarea personalizada que se envuelve sustitución de cadenas:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using Microsoft.Build.Utilities; 
using Microsoft.Build.Framework; 

namespace SynchBuild 
{ 
    public class RemoveAsterisk : Task 
    { 
     private string myVersion; 

     [Required] 
     public string Version 
     { 
      set{myVersion = value;} 
     } 


     [Output] 
     public string ReturnValue 
     { 
      get { return myVersion.Replace("*", ""); } 
     } 


     public override bool Execute() 
     { 
      return true; 
     } 
    } 
} 

Para que se construye en SynchBuild.dll que se ve hace referencia en la UsingTask a continuación. Ahora he intentado simplemente overwritting la propiedad MinimumRequiredVersion, pero no parecía ser recogido, por lo que sólo sobreescribí el objetivo GenerateApplicationManifest añadiendo las siguientes líneas al final de mi archivo csproj:

<UsingTask AssemblyFile="$(MSBuildExtensionsPath)\WegmansBuildTasks\SynchBuild.dll" TaskName="SynchBuild.RemoveAsterisk" /> 
    <Target Name="GenerateDeploymentManifest" DependsOnTargets="GenerateApplicationManifest" Inputs="&#xD;&#xA;   $(MSBuildAllProjects);&#xD;&#xA;   @(ApplicationManifest)&#xD;&#xA;   " Outputs="@(DeployManifest)"> 
    <RemoveAsterisk Version="$(ApplicationVersion)$(ApplicationRevision)"> 
     <Output TaskParameter="ReturnValue" PropertyName="MinimumRequiredVersion" /> 
    </RemoveAsterisk> 
    <GenerateDeploymentManifest MinimumRequiredVersion="$(MinimumRequiredVersion)" AssemblyName="$(_DeploymentDeployManifestIdentity)" AssemblyVersion="$(_DeploymentManifestVersion)" CreateDesktopShortcut="$(CreateDesktopShortcut)" DeploymentUrl="$(_DeploymentFormattedDeploymentUrl)" Description="$(Description)" DisallowUrlActivation="$(DisallowUrlActivation)" EntryPoint="@(_DeploymentResolvedDeploymentManifestEntryPoint)" ErrorReportUrl="$(_DeploymentFormattedErrorReportUrl)" Install="$(Install)" MapFileExtensions="$(MapFileExtensions)" MaxTargetPath="$(MaxTargetPath)" OutputManifest="@(DeployManifest)" Platform="$(PlatformTarget)" Product="$(ProductName)" Publisher="$(PublisherName)" SuiteName="$(SuiteName)" SupportUrl="$(_DeploymentFormattedSupportUrl)" TargetCulture="$(TargetCulture)" TargetFrameworkVersion="$(TargetFrameworkVersion)" TrustUrlParameters="$(TrustUrlParameters)" UpdateEnabled="$(UpdateEnabled)" UpdateInterval="$(_DeploymentBuiltUpdateInterval)" UpdateMode="$(UpdateMode)" UpdateUnit="$(_DeploymentBuiltUpdateIntervalUnits)" Condition="'$(GenerateClickOnceManifests)'=='true'"> 
     <Output TaskParameter="OutputManifest" ItemName="FileWrites" /> 
</GenerateDeploymentManifest> 
    </Target> 

El resultado final es que tomamos la versión y revisión de la aplicación, las combinamos, eliminamos el asterisco y luego establecemos la versión mínima requerida. Tengo la versión de la aplicación de incremento automático en mis propiedades de publicación así que así es como se produce el incremento, entonces solo estoy configurando la versión mínima requerida para que coincida siempre. No uso la compilación en equipo, esto está diseñado para que un desarrollador use Visual Studio. puede hacer todas las implementaciones de clickonce requeridas. Espero que esto ayude.

Answer 6

Si está publicando su aplicación ClickOnce desde Visual Studio, simplemente instale el AutoUpdateProjectsMinimumRequiredClickOnceVersion NuGet Package en su proyecto y listo.

Si está publicando desde un servidor de compilación u otro script, puede usar el Set-ProjectFilesClickOnceVersion PowerShell script. Mi blog describe con más detalle how to setup your build server to accommodate publishing ClickOnce applications.