[ 转载]UAB

原创 2005年03月02日 21:14:00

用Application Updater Block生成一个自我更新的WinForms 应用

bigtall

原文地址

在过去的两个星期里, 我一直在做我的第一个真正的.net WinForm应用的开发.  这是一个很有趣的过程,我一直在疯了似的学习东西.  其中之一就是我要允许应用程序能够用微软的Application Updater Block进行自我更新。  当它正常工作的那一刻,让我有一种很大的成就感,同时我也意识到微软没有提供那种按步骤顺序的例子。  Duncan Mackenzie 有一个 很好的blog文章 可以做一个开始,但是这个例子是VB做的并且没有提供RSA公钥和私钥的细节情况,所以我决定说一下我的工作过程。  希望能对你有用!

Step #1 Install the Application Blocks

Download the Updater Application Block from Microsoft .

Run the MSI Installer.

Step #2 在项目中加入代码和引用:

把下列工程加入到你的WinForm工程所在的解决方案:

Microsoft.ApplicationBlocks.ApplicationUpdater
Microsoft.ApplicationBlocks.ApplicationUpdater.Interfaces
Microsoft.ApplicationBlocks.ExceptionManagement
Microsoft.ApplicationBlocks.ExceptionManagement.Interfaces

如果你选择默认安装的话,它们的位置可能是:

C:/Program Files/Microsoft Application Blocks for .NET/Updater/Code/CS/Microsoft.ApplicationBlocks.Updater

在你的WinForm工程中引用下列工程

Microsoft.ApplicationBlocks.ApplicationUpdater
Microsoft.ApplicationBlocks.ApplicationUpdater.Interfaces
Microsoft.ApplicationBlocks.ExceptionManagement

把下列命名空间加入到你Form的.cs文件中

using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Threading;
using System.Diagnostics;
using System.IO;
using System.Xml;

然后 添加这个位置的应用程序更新代码到你的代码中.  你需要从你的MainForm初始化方法中调用 InitializeAutoUpdate()。

Step #3 生成你应用程序的发布目录结构并配置 AppStart.exe

生成一个用于客户端程序安装的目录.  本例子中,我们用如下的目录:

C:/Program Files/YourApp/1.0.0.0/

现在复制 AppStart.exeAppStart.exe.config 到类似如下的根目录中

 C:/Program Files/YourApp/AppStart.exe
 C:/Program Files/YourApp/AppStart.exe.config

说明: 这两个文件你可以在如下目录中找到 “C:/Program Files/Microsoft Application Blocks for .NET/Updater/Code/CS/Microsoft.ApplicationBlocks.Updater/AppStart/bin/Debug“  

Step #4 修改 AppStart.exe.config 文件

AppStart.exe 会启动你的应用程序,如果更新文件下载完成之后还有可能要重启.  它需要知道启动你最新的程序的目录位置. 
修改配置文件以配合当前的版本:

<appStart>
 
<ClientApplicationInfo
>
   
<appFolderName>C:/Program Files/YourApp/1.0.0.0</appFolderName
>
   
<appExeName>YourAppName.exe</appExeName
>
   
<installedVersion>1.0.0.0</installedVersion
>
   
<lastUpdated>2004-06-10T15:33:17.3745836-04:00</lastUpdated
>
 
</ClientApplicationInfo
>
</appStart>

Step #5: 生成你的公钥和私钥

运行 "C:/Program Files/Microsoft Application Blocks for .NET/Updater/Code/CS/Microsoft.ApplicationBlocks.Updater/ManifestUtility/bin/Debug/ManifestUtility.exe"

选择 “File..Generate Keys”  会提示你是否需要保存: PublicKey.xml 和 PrivateKey.xml  这两个密钥接下来就会用到. 

我这里要提醒大家,这些密钥只要生成一次就可以了, 因为下面几个地方需要引用到RSA公钥和私钥.  你需要把这些密钥存放在一个安全的地方,因为在发布一个新的更新的时候会用到它

Step #6 创建IIS 虚拟目录

在你的Web服务器上生成一个目录来存放你的更新文件.  在这两个目录中要放两样东西 1)  ServerManifest.xml 文件,包含最后版本的一些信息;2) 你的新程序的目录. 在这个目录里,生成一个目录来存放你的新版本程序.  在我们的例子中,我们用这两个目录, C:/Inetpub/AppUpdates C:/Inetpub/AppUpdates/1.0.0.1

用 IIS 管理器生成一个虚拟目录指向刚才的实际目录.  记下你的 URL, 在上传步骤中我们需要用到它.  你必须要打开虚拟目录的“目录浏览”选项.

Step #7. 配置你的版本 1.0.0.0 的App.config 文件

这里,我们会需要往里添加一些新东西.  首先, 我们需要加入一个configSections 元素来定义我们的 appUpdater 节:

<configSections>
 
<section name="appUpdater" type="Microsoft.ApplicationBlocks.ApplicationUpdater.UpdaterSectionHandler,Microsoft.ApplicationBlocks.ApplicationUpdater"
/>
</configSections>

接下来,我们需要添加一个 Version 键到我们的 appsettings 中, 我们首先设置我们的本地版本为 1.0.0.0, 这样我们就可以测试自动更新到版本 1.0.0.1

<appSettings>
 
<add key="VERSION" value="1.0.0.0"
/>
</appSettings>

最后,, 加入 appUpdater 节到你的配置文件中.  我这里用一对方括号把你要修改的值包含起来.  你可以直接从你上一步生成的 PublicKey.xml文件中复制 <RSAKeyValue> 元素.

<xmlFile> 元素必须要指向你在Step #6创建的虚拟目录的 URL .

<appUpdater>
  <UpdaterConfiguration
>
   <polling type="Seconds" value="120"
/>
  
<logListener logPath="C:/Program Files/YourApp/UpdaterLog.txt"
/>
   <downloader type="Microsoft.ApplicationBlocks.ApplicationUpdater.Downloaders.BITSDownloader"

assembly
="Microsoft.ApplicationBlocks.ApplicationUpdater,Version=1.0.0.0,Culture=neutral,PublicKeyToken=null"/>
 
  <validator type="Microsoft.ApplicationBlocks.ApplicationUpdater.Validators.RSAValidator" assembly
="Microsoft.ApplicationBlocks.ApplicationUpdater,Version=1.0.0.0,Culture=neutral,PublicKeyToken=null">
 
<key
>
  
<RSAKeyValue
>
  
<Modulus>[YOUR MODULUS KEY]</Modulus
>
 
<Exponent>[YOUR EXPONENET]</Exponent
>
 
</RSAKeyValue
>
 
</key
>
 
</validator> 
  <application name="[YOUR APP NAME]" useValidation
="true">
   
<client
>
     
<baseDir>C:/Program Files/YourApp</baseDir
>
     
<xmlFile>C:/Program Files/YourApp/AppStart.exe.config</xmlFile
>
     
<tempDir>C:/Program Files/YourApp/temp</tempDir
>
   
</client
>
    <server
>
     
<xmlFile>http://[YOUR URL]/ServerManifest.xml</xmlFile
>
    
<xmlFileDest>C:/Program Files/YourApp/ServerManifest.xml</xmlFileDest
>
    
<maxWaitXmlFile>60000</maxWaitXmlFile
>
   
</server
>
  </application
>
 </UpdaterConfiguration
>
 
</appUpdater>

Step #8 发布版本 1.0.0.0

设置应用程序版本号.  可以通过设置在 AssemblyInfo.cs 文件中的版本属性来设置版本号.

[assembly: AssemblyVersion("1.0.0.0")]

编译应用程序并复制 1.0.0.0 版程序到你程序的 1.0.0.0 目录中. “C:/Program Files/YourApp/1.0.0.0“

这里,你需要运行一下 AppStart.exe.  更新过程会失败,因为我们并没有把发布 ServerManifest XML 文件来指示应用程序新版本是否可用.  你可以检查日志文件,位置在 C:/Program Files/YourApp/ 目录中.

Step #9 构建版本 1.0.0.1 

这是最有趣的部分.  首先, 通过更新应用程序的 AssemblyInfo.cs 和 App.config 文件内容来生成修订版本 1.0.0.1 .  编译程序, 然后复制文件到step #6生成的Web服务器目录中. 

Step #10 生成服务器的清单文件

这个是最后一步.  如果你对本步骤中的.config文件作了任何修改的话,都必须把本步骤重来一遍.  做法如下:

  1. 再次运行 ManifestUtility 程序. 
  2. 在 “Update files folder“ 选择器中选择 1.0.0.1 目录 . 
  3. 输入更新位置的 URL . 
  4. 输入新版本号 1.0.0.1
  5. 打开之前生成的 PrivateKey.xml 文件.
  6. 选择验证类 “Microsoft.ApplicationBlocks.ApplicationUpdater.Validators.RSAValidator”
  7. 鼠标点击 CreateManifest, 并保存 ServerManifest.xml 文件到你的虚拟服务器目录中.

就这些!  Pheeew!  从你的 C:/Program Files/YourApp/ 目录中运行你的 AppStart.exe .  你的程序就会被装入, 当你的程序运行的时候,你就会得到一个提示 “新版本可用” .  新版本会下载到目录 C:/Program Files/YourApp/1.0.0.1 中, 然后程序会自动重启.  如果有任何问题, 记得检查一下日志文件.  这些日志在诊断问题的时候会很有用的.

-Brendan

posted on Thursday, June 10, 2004 11:25 AM
附录:文中步骤 #2 包含的代码如下:
#region Auto-Update Stuff
    
private ApplicationUpdateManager _updater = null;
private Thread _updaterThread = null;
private const int UPDATERTHREAD_JOIN_TIMEOUT = 3 * 1000;

private delegate void MarshalEventDelegate( object sender, UpdaterActionEventArgs e );

private void InitializeAutoUpdate()
{
    
//  hook ProcessExit for a chance to clean up when closed peremptorily
    AppDomain.CurrentDomain.ProcessExit +=new EventHandler(CurrentDomain_ProcessExit);

    
//  make an Updater for use in-process with us
    _updater = new ApplicationUpdateManager();

    
//  hook Updater events
    _updater.DownloadStarted +=new UpdaterActionEventHandler( OnUpdaterDownloadStarted );
    _updater.FilesValidated 
+=new UpdaterActionEventHandler( OnUpdaterFilesValidated );
    _updater.UpdateAvailable 
+=new UpdaterActionEventHandler( OnUpdaterUpdateAvailable );
    _updater.DownloadCompleted 
+=new UpdaterActionEventHandler(OnUpdaterDownloadCompleted);

    
//  start the updater on a separate thread so that our UI remains responsive
    _updaterThread = new Thread( new ThreadStart( _updater.StartUpdater ) );
    _updaterThread.Start();

    
//  get version from config, set caption correctly
    string version = System.Configuration.ConfigurationSettings.AppSettings["version"];
    
this.Text = this.Text + String.Format(" v. {0}", version);
}


private void CurrentDomain_ProcessExit(object sender, EventArgs e)
{
    StopUpdater();
}



private void StopUpdater()
{
    
//  tell updater to stop
    _updater.StopUpdater();
    
ifnull != _updaterThread )
    
{
        
//  join the updater thread with a suitable timeout
        bool isThreadJoined = _updaterThread.Join( UPDATERTHREAD_JOIN_TIMEOUT );
        
//  check if we joined, if we didn't interrupt the thread
        if!isThreadJoined )
        
{    
            _updaterThread.Interrupt();
        }

        _updaterThread 
= null;
    }

}


/// <summary>
/// This handler gets fired by the Windows UI thread that is the main STA thread for THIS FORM.  It takes the same 
/// arguments as the event handler below it--sender, e--and acts on them using the main thread NOT the eventing thread
/// </summary>
/// <param name="sender">marshalled reference to the original event's sender argument</param>
/// <param name="e">marshalled reference to the original event's args</param>

private void OnUpdaterDownloadStartedHandler( object sender, UpdaterActionEventArgs e ) 
{
    Debug.WriteLine(
"Thread: " + Thread.CurrentThread.GetHashCode().ToString());

    Debug.WriteLine(String.Format( 
"  DownloadStarted for application '{0}'", e.ApplicationName ));
}



/// <summary>
/// Event handler for Updater event.  This event is fired by the originating thread from "inside" the Updater.  While it is
/// possible for this same thread to act on our UI, it is NOT a good thing to do--UI is not threadsafe.  
/// Therefore here we marshal from the Eventing thread (belongs to Updater) to our window thread using the synchronous Invoke
/// mechanism.
/// </summary>
/// <param name="sender">event sender in this case ApplicationUpdaterManager</param>
/// <param name="e">the UpdaterActionEventArgs packaged by Updater, which gives us access to update information</param>

private void OnUpdaterDownloadStarted( object sender, UpdaterActionEventArgs e )

    
//  using the synchronous "Invoke".  This marshals from the eventing thread--which comes from the Updater and should not
    
//  be allowed to enter and "touch" the UI's window thread
    
//  so we use Invoke which allows us to block the Updater thread at will while only allowing window thread to update UI
    Debug.WriteLine( String.Format( "[OnUpdaterDownloadStarted]Thread: {0}", Thread.CurrentThread.GetHashCode().ToString()) );
    
this.Invoke( 
            
new MarshalEventDelegate( this.OnUpdaterDownloadStartedHandler ), 
            
new object[] { sender, e } );
}



/// <summary>
/// This handler gets fired by the Windows UI thread that is the main STA thread for THIS FORM.  It takes the same 
/// arguments as the event handler below it--sender, e--and acts on them using the main thread NOT the eventing thread
/// </summary>
/// <param name="sender">marshalled reference to the original event's sender argument</param>
/// <param name="e">marshalled reference to the original event's args</param>

private void OnUpdaterFilesValidatedHandler( object sender, UpdaterActionEventArgs e )
{
    Debug.WriteLine(String.Format(
"FilesValidated successfully for application '{0}' ", e.ApplicationName));
    
    
//  ask user to use new app
    DialogResult dialog = MessageBox.Show( 
            
"Would you like to stop this application and open the new version?""Open New Version?", MessageBoxButtons.YesNo );
    
if( DialogResult.Yes == dialog )
    
{
        StartNewVersion( e.ServerInformation );
    }

}


/// <summary>
/// Event handler for Updater event.  This event is fired by the originating thread from "inside" the Updater.  While it is
/// possible for this same thread to act on our UI, it is NOT a good thing to do--UI is not threadsafe.  
/// Therefore here we marshal from the Eventing thread (belongs to Updater) to our window thread using the synchronous Invoke
/// mechanism.
/// </summary>
/// <param name="sender">event sender in this case ApplicationUpdaterManager</param>
/// <param name="e">the UpdaterActionEventArgs packaged by Updater, which gives us access to update information</param>

private void OnUpdaterFilesValidated( object sender, UpdaterActionEventArgs e )
{
    
//  using the asynchronous "BeginInvoke".  
    
//  we don't need/want to block here
    this.BeginInvoke( 
            
new MarshalEventDelegate( this.OnUpdaterFilesValidatedHandler ),
            
new object[] { sender, e } );
}



/// <summary>
/// This handler gets fired by the Windows UI thread that is the main STA thread for THIS FORM.  It takes the same 
/// arguments as the event handler below it--sender, e--and acts on them using the main thread NOT the eventing thread
/// </summary>
/// <param name="sender">marshalled reference to the original event's sender argument</param>
/// <param name="e">marshalled reference to the original event's args</param>

private void OnUpdaterUpdateAvailableHandler( object sender, UpdaterActionEventArgs e )
{    
    Debug.WriteLine(
"Thread: " + Thread.CurrentThread.GetHashCode().ToString());

    
string message = String.Format( 
        
"Update available:  The new version on the server is {0} and current version is {1} would you like to upgrade?"
        e.ServerInformation.AvailableVersion,  
        System.Configuration.ConfigurationSettings.AppSettings[
"version"] ) ;

    
//  for update available we actually WANT to block the downloading thread so we can refuse an update
    
//  and reset until next polling cycle;
    
//  NOTE that we don't block the thread _in the UI_, we have it blocked at the marshalling dispatcher "OnUpdaterUpdateAvailable"
    DialogResult dialog = MessageBox.Show( message, "Update Available", MessageBoxButtons.YesNo );

    
if( DialogResult.No == dialog )
    
{
        
//  if no, stop the updater for this app
        _updater.StopUpdater( e.ApplicationName );
        Debug.WriteLine(
"Update Cancelled.");
    }

    
else
    
{
        Debug.WriteLine(
"Update in progress.");
    }

}


/// <summary>
/// Event handler for Updater event.  This event is fired by the originating thread from "inside" the Updater.  While it is
/// possible for this same thread to act on our UI, it is NOT a good thing to do--UI is not threadsafe.  
/// Therefore here we marshal from the Eventing thread (belongs to Updater) to our window thread using the synchronous Invoke
/// mechanism.
/// </summary>
/// <param name="sender">event sender in this case ApplicationUpdaterManager</param>
/// <param name="e">the UpdaterActionEventArgs packaged by Updater, which gives us access to update information</param>

private void OnUpdaterUpdateAvailable( object sender, UpdaterActionEventArgs e )
{
    
//  using the synchronous "Invoke".  This marshals from the eventing thread--which comes from the Updater and should not
    
//  be allowed to enter and "touch" the UI's window thread
    
//  so we use Invoke which allows us to block the Updater thread at will while only allowing window thread to update UI
    this.Invoke( 
        
new MarshalEventDelegate( this.OnUpdaterUpdateAvailableHandler ), 
        
new object[] { sender, e } );
}


    
/// <summary>
/// This handler gets fired by the Windows UI thread that is the main STA thread for THIS FORM.  It takes the same 
/// arguments as the event handler below it--sender, e--and acts on them using the main thread NOT the eventing thread
/// </summary>
/// <param name="sender">marshalled reference to the original event's sender argument</param>
/// <param name="e">marshalled reference to the original event's args</param>

private void OnUpdaterDownloadCompletedHandler( object sender, UpdaterActionEventArgs e )
{
    Debug.WriteLine(
"Download Completed.");

}


/// <summary>
/// Event handler for Updater event.  This event is fired by the originating thread from "inside" the Updater.  While it is
/// possible for this same thread to act on our UI, it is NOT a good thing to do--UI is not threadsafe.  
/// Therefore here we marshal from the Eventing thread (belongs to Updater) to our window thread using the synchronous Invoke
/// mechanism.
/// </summary>
/// <param name="sender">event sender in this case ApplicationUpdaterManager</param>
/// <param name="e">the UpdaterActionEventArgs packaged by Updater, which gives us access to update information</param>

private void OnUpdaterDownloadCompleted( object sender, UpdaterActionEventArgs e )
{
    
//  using the synchronous "Invoke".  This marshals from the eventing thread--which comes from the Updater and should not
    
//  be allowed to enter and "touch" the UI's window thread
    
//  so we use Invoke which allows us to block the Updater thread at will while only allowing window thread to update UI
    this.Invoke( 
        
new MarshalEventDelegate( this.OnUpdaterDownloadCompletedHandler ), 
        
new object[] { sender, e } );
}



private void StartNewVersion( ServerApplicationInfo server )
{
    XmlDocument doc 
= new XmlDocument();

    
//  load config file to get base dir
    doc.Load( AppDomain.CurrentDomain.SetupInformation.ConfigurationFile );

    
//  get the base dir
    string baseDir = doc.SelectSingleNode("configuration/appUpdater/UpdaterConfiguration/application/client/baseDir").InnerText;
    
string newDir = Path.Combine( baseDir, "AppStart.exe" );

    ProcessStartInfo process 
= new ProcessStartInfo( newDir );
    process.WorkingDirectory 
= Path.Combine( newDir , server.AvailableVersion );

    
//  launch new version (actually, launch AppStart.exe which HAS pointer to new version )
    Process.Start( process );

    
//  tell updater to stop
    CurrentDomain_ProcessExit( nullnull );
    
//  leave this app
    Environment.Exit( 0 );
}


USBgrasp.rar uab侦听

  • 2009年03月19日 22:39
  • 186KB
  • 下载

转载 《算法设计与分析试题》

  • 2015年07月24日 21:40
  • 52KB
  • 下载

【转载】IDEA中如何配置Tomcat和项目?

IDEA中如何配置Tomcat和项目IDEA是我用的挺多的一款java代码编辑工具,对于刚接触这款软件的新手来说,配置项目是很麻烦的了,更别说配置服务器Tomcat了,那么通过我的教程大家一定觉得配置...

转载:酷炫背景------瀑布流

  • 2017年11月06日 17:45
  • 74KB
  • 下载

NTP的配置总结(整理+转载)

NTPServer/Client的配置和常见问题的解决方法。
  • gycool21
  • gycool21
  • 2016年06月23日 19:29
  • 10671

黑莓9700拆机图(转载)

  • 2013年09月20日 20:36
  • 1.06MB
  • 下载

动态光源模组1.7.10 转载自mcbbs

  • 2016年02月24日 20:40
  • 572KB
  • 下载

StringbeansTM Portal管理手册<译>[转载请标出处]

StringbeansTM Portal管理手册 Stringbeans框架下的门户网站管理指南 最近在学习Portal网站开发,接解到Stringbeans框架,在学习的过程中,翻译了该...

程序员的思维修炼(转载)

  • 2017年08月01日 14:35
  • 2.25MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:[ 转载]UAB
举报原因:
原因补充:

(最多只允许输入30个字)