## Updating the `MinimumRequiredVersion` Automatically


### Introduction to Project Editor


1. In Solution Explorer, right click on your project and select unload project.

 ![Screenshot of Unloading][unload]

2. Once the project has become unavailable, right click again and select edit *`<project_name>.<lang>`* proj.

 ![Screenshot of Opening Editor][edit]


### Introduction to MSBuild

3. Properties use key/value pairs to extract information

 * Using the property name as an alias, you can use `$(OutputPath)` to obtain the value for the element `<OutputPath>.\bin</OutputPath>`

4. We’ll use the following properties generated for a ClickOnce deployment

    
    
        <MinimumRequiredVersion>1.0.0.6</MinimumRequiredVersion>
        <ApplicationRevision>7</ApplicationRevision>
        <ApplicationVersion>1.0.0.%2a</ApplicationVersion>


5. `MSBuild Tasks` can be specified in the project (*.proj) file and invoked during a build event.

 * [`FormatVersion`](http://msdn.microsoft.com/en-us/library/ff595162.aspx) is a built-in task for .NET 4.0 and later that formats the ApplicationVersion and ApplicationRevision into a single version number.


### Implementation


6. Copy and Paste the following code into the opened project file as a child element to the root `<Project>` element.


    
    
    
        <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>


  This code will take ApplicationVersion and ApplicationRevision as parameters in the Format Version task and will save the output by overwriting the MinimumRequiredVersion with the full publish version.

7. Save and reload your project.  Every ClickOnce deployment will now automatically update to the most recently published version.

---

*Many thanks to Kev for [their answer][answer] which I have basically rehashed here with a little bit of added clarification for any beginners.* Here's a [blog post][blog] I made about the issue that expands even more on my answer here.

 [album]:  http://imgur.com/a/ipDKy
 [unload]: http://i.stack.imgur.com/7nAnm.png
 [edit]:   http://i.stack.imgur.com/bgcUL.png
 [answer]: https://stackoverflow.com/a/13483142/1366033
 [blog]:   http://www.codingeverything.com/2013/05/automatically-increment-minimum.html

We have an [NAnt][1] script that checks out from [CVS][2] and then runs [MSBuild][3] to publish the application. The problem is we have to remember to always increment the version in Visual Studio.

We have the option to auto increment this on publish, but this gets wiped on the next checkout and I would rather not have to get the build script to check in the project file.

Is there a simple way to do this?

  [1]: http://en.wikipedia.org/wiki/NAnt
  [2]: http://en.wikipedia.org/wiki/Concurrent_Versions_System
  [3]: http://en.wikipedia.org/wiki/MSBuild


How can I get MSBuild to increment the ClickOnce publish revision version number on a build server?

We current do manual builds/publish from Visual Studio 2010 and we require users to always be running the latest version (check before startup and minimum required version set). I am working on scripting our deployment out and have no issues using msbuild to build/publish. However, I have not found a way to auto-increment the minimum required version when msbuild runs. What are my options to automatically bump this when publishing via msbuild?

I did see quite a few articles on this topic here, but they seemed to be specific to VS and not MSBuild.

ClickOnce deployment minumum required version auto-increment with MSBuild

One approach is to use [application settings][1], which we used for a WPF application deployed with ClickOnce.  We have multiple settings for such things as user specified download folders, default settings, etc.  For each such setting, the *Scope* is set to User.  When the setting is changed by the user the new values are persisted with a call such as:

    YourProject.Properties.Settings.Default.UserSetting1 = "New Value";
    YourProject.Properties.Settings.Default.Save(); // persists the new value for the current user

Even with multiple updates of the application via ClickOnce, these settings are persisted for each user.  Note that the settings are persisted on a per-machine basis, so if a user goes to a new machine and downloads the application, their settings will not be transferred.

Hope this helps,


  [1]: http://msdn.microsoft.com/en-us/library/k4s6c3a0%28v=vs.100%29.aspx

I'd like to deploy a ClickOnce application, but would like to have a configurable user file to store settings and preferences that does not get overwritten everytime I publish a new version.  Is there to specify that a particular file should get deployed in any installation that doesn't already have one, but not overwrite any previous versions?

The only workaround that I can envision is to store the data in a database, but it's so user-centric that it seems like a lot of overhead to re-invent the config file.

ClickOnce Deployment with local user file

ClickOnce doesn't pass through standard command line args, but through the [ActivationArguments][1] instead.

Your file info should be available via 
`AppDomain.CurrentDomain.SetupInformation.ActivationArguments.ActivationData`


  [1]: https://msdn.microsoft.com/en-us/library/system.runtime.hosting.activationarguments.activationdata(v=vs.110).aspx

I'm trying to associate an application with a particular file type and then use that file when the application starts up. It's pretty trivial to [Create File Associations For a ClickOnce Application][File Association]:

![Publish Options > File Associations][Publish Options]


This currently works, so if I have an file with the extension ".tester," my Click Once Deployed application will fire up.

The problem I'm having trouble with is *identifying which file launched the application*.

According to the question [What Event is Triggered When Opening a Custom File?][Open File Event], the "file should be available from the command line args", and this [Scott Hanselman Article confirms][Hanselman].

However, when I add the following code, I don't get anything besides the path to the executable when firing the application.



    Dim args = Environment.GetCommandLineArgs()
    MsgBox(Join(args, ", "))

![Command Line Args][args 1]

I have confirmed that I'm fetching all the command line arguments.  When I launch the file from the actual command line with some bogus arguments:



    C:\FileHandler.exe -foo bar

The application will display the following: 

![args 2][args 2]

**How do I identify the file that initiated the application?**


[File Association]: https://msdn.microsoft.com/en-us/library/bb892924.aspx
[Publish Options]: http://i.stack.imgur.com/DfH6T.png
[Open File Event]: https://stackoverflow.com/q/16476182/1366033

[Hanselman]: http://www.hanselman.com/blog/TheWeeklySourceCode31SingleInstanceWinFormsAndMicrosoftVisualBasicdll.aspx
[args 1]: http://i.stack.imgur.com/H289G.png
[args 2]: http://i.stack.imgur.com/yV5NT.png