winform更新程序代码

这是我的第一个随笔，写的不好的或者语法错误等，请大家不要见怪，首先预览下截图

 

自动更新一般分3部分：

1、发现更新

2、下载文件

3、复制文件

下面对以上3个过程做简单的介绍

发现更新

根据客户端的配置文件的manifestUri去读取服务器的xml文件，然后依次比较applicationId和version，如果applicationId一致且version不一致则可以更新，客户端配置文件不是app.config，而是一个自己定义的xml文件，至于为什么不用app.config文件的原因很简单，因为app.config在系统运行的时候是不能进行修改的，客户端配置文件内容大概如下：

<?xml version="1.0" encoding="utf-8"?>
<applicationUpdater applicationId="{4a1e1623-bd3c-4921-8d91-85d34a5fe518}"
                        manifestUri="http://127.0.0.1/manifests.xml"
                        version="1.04">
</applicationUpdater>

applicationId表示运用程序Id，这个要跟服务器上的xml的applicationId一致，否则程序不会更新；

manifestUri表示服务器xml的地址

version表示当前版本，版本跟服务器上的不一致就更新

 

服务器端配置文件内容大概如下：

<?xml version="1.0" encoding="utf-8" ?>
<manifest>
  <!--版本号，无格式要求，更新时需要修改-->
  <version>1.2</version>
  <description>更新说明，更新时需要修改</description>
  <!--applicationId运用程序ID，无格式要求，需要与客户端配置一样，否则不会进行更新-->
  <application applicationId="{215E1AD7-9ABA-432f-A952-24BABA556850}">
    <!--重新启动exe名称，parameters启动时传入的参数-->
    <entryPoint file="Client.exe" parameters="client" />
    <!--更新文件的目录，相对于更新系统，默认为同级目录-->
    <location>.</location>
  </application>
  <!--base表示存放该文件的url-->
  <files base="http://localhost/update/">
    <!--文件名称，更新时需要修改-->
    <file source="test.txt" />
    <file source="Client.exe" />
  </files>
</manifest>

XML对应的实体类

[XmlRoot("manifest")]
    public class Manifest
    {
        [XmlElement("version")]
        public string Version { get; set; }

        [XmlElement("description")]
        public string Description { get; set; }

        [XmlElement("fileBytes")]
        public long FileBytes { get; set; }

        [XmlElement("application")]
        public Application Application { get; set; }

        [XmlElement("files")]
        public ManifestFiles ManifestFiles { get; set; }
    }

    public class ManifestFiles
    {
        [XmlElement("file")]
        public ManifestFile[] Files { get; set; }

        [XmlAttribute("base")]
        public string BaseUrl { get; set; }
    }

    public class ManifestFile
    {
        [XmlAttribute("source")]
        public string Source
        {
            get;
            set;
        }

        [XmlAttribute("hash")]
        public string Hash
        {
            get;
            set;
        }
    }

    public class Application
    {
        [XmlAttribute("applicationId")]
        public string ApplicationId { get; set; }

        [XmlElement("location")]
        public string Location { get; set; }

        [XmlElement("entryPoint")]
        public EntryPoint EntryPoint { get; set; }
    }

    public class EntryPoint
    {
        [XmlAttribute("file")]
        public string File { get; set; }

        [XmlAttribute("parameters")]
        public string Parameters { get; set; }
    }

    public class UpdaterConfigurationView
    {
        private static XmlDocument document = new XmlDocument();
        private static readonly string xmlFileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "updateconfiguration.config");

        static UpdaterConfigurationView()
        {
            document.Load(xmlFileName);
        }

        public string Version
        {
            get
            {
                return document.SelectSingleNode("applicationUpdater").Attributes["version"].Value;
            }
            set
            {
                document.SelectSingleNode("applicationUpdater").Attributes["version"].Value = value;
                document.Save(xmlFileName);
            }
        }

        public string ApplicationId
        {
            get
            {
                return document.SelectSingleNode("applicationUpdater").Attributes["applicationId"].Value;
            }
            set
            {
                document.SelectSingleNode("applicationUpdater").Attributes["applicationId"].Value = value;
                document.Save(xmlFileName);
            }
        }

        public string ManifestUri
        {
            get
            {
                return document.SelectSingleNode("applicationUpdater").Attributes["manifestUri"].Value;
            }
            set
            {
                document.SelectSingleNode("applicationUpdater").Attributes["manifestUri"].Value = value;
                document.Save(xmlFileName);
            }
        }
    }

 

 

 

下载文件

 下载文件是根据服务器端的配置文件进行的，配置文件设置了下载的文件路径，下载地址的url，下载文件保存的位置，由location节点设置，好了，不多说了，看下载的源码，这里我是写了一个可以异步下载的组件，里面用的是Ms自带的WebClient类，异步下载有事件通知，详见源码：

事件类

public class DownloadErrorEventArgs : EventArgs
    {
        public Exception Error { get; set; }

        public Manifest Manifest { get; set; }
    }

    public class DownloadProgressEventArgs : ProgressChangedEventArgs
    {
        public DownloadProgressEventArgs(int progressPercentage, object userState)
            : base(progressPercentage,userState)
        { }

        /// <summary>
        /// 当前下载的文件名
        /// </summary>
        public string FileName { get; set; }

        /// <summary>
        /// 获取收到的字节数。
        /// </summary>
        public long BytesReceived { get; set; }
        /// <summary>
        /// 获取 System.Net.WebClient 数据下载操作中的字节总数。
        /// </summary>
        public long TotalBytesToReceive { get; set; }
    }

    public class DownloadCompleteEventArgs : AsyncCompletedEventArgs
    {
        public DownloadCompleteEventArgs(Exception error, bool cancelled, object userState)
            : base(error, cancelled, userState)
        { 
        }

        public Manifest Manifest { get; set; }
    }

 下载代码

public class DownloadClass : Component
    {
        private WebClient webClient=new WebClient();
        private Manifest manifest;
        private int fileCount = 0;
        private bool cancel = false;
        private string tempPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "temp");

        private HybridDictionary userStateToLifetime = new HybridDictionary();
        private object defaultTaskId = new object();
        private delegate void WorkerEventHandler(AsyncOperation asyncOp);
        private System.ComponentModel.Container components = null;
        private SendOrPostCallback onProgressReportDelegate;
        private SendOrPostCallback onCompletedDelegate;
        private AsyncOperation current;

        /// <summary>
        /// 下载进度
        /// </summary>
        public event EventHandler<DownloadProgressEventArgs> DownloadProgressChanged;
        /// <summary>
        /// 下载完成事件
        /// </summary>
        public event EventHandler<DownloadCompleteEventArgs> DownloadCompleted;
        /// <summary>
        /// 下载错误触发的事件
        /// </summary>
        public event EventHandler<DownloadErrorEventArgs> DownloadError;

        public DownloadClass(IContainer container)
        {
            container.Add(this);
            InitializeComponent();
            InitializeDelegates();
        }

        public DownloadClass()
        {
            InitializeComponent();
            InitializeDelegates();
        }

        /// <summary>
        /// 初始化代理
        /// </summary>
        protected virtual void InitializeDelegates()
        {
            onProgressReportDelegate = new SendOrPostCallback(ReportProgress);
            onCompletedDelegate = new SendOrPostCallback(DoDownloadCompleted);
        }

        /// <summary>
        /// 触发下载进度事件
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnDownloadProgressChanged(DownloadProgressEventArgs e)
        {
            if (DownloadProgressChanged != null)
            {
                DownloadProgressChanged(this, e);
            }
        }

        /// <summary>
        /// 触发下载完成事件
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnDownloadCompleted(DownloadCompleteEventArgs e)
        {
            if (DownloadCompleted != null)
            {
                DownloadCompleted(this, e);
            }
        }

        /// <summary>
        /// 触发下载错误事件
        /// </summary>
        /// <param name="e"></param>
        protected virtual void OnDownloadError(DownloadErrorEventArgs e)
        {
            if (DownloadError != null)
            {
                DownloadError(this, e);
            }
        }

        /// <summary>
        /// 下载文字保存的临时目录
        /// </summary>
        public string TempPath
        {
            get
            {
                return tempPath;
            }
            set
            {
                tempPath = value;
            }
        }

        /// <summary>
        /// 同步下载
        /// </summary>
        /// <param name="manifest"></param>
        public void Download(Manifest manifest)
        {
            Init(manifest);
            foreach (var file in manifest.ManifestFiles.Files)
            {
                string serverFileName = Path.Combine(manifest.ManifestFiles.BaseUrl, file.Source);
                string clientFileName = Path.Combine(tempPath, file.Source);
                Uri uri = new Uri(serverFileName);
                if (!Directory.Exists(Path.GetDirectoryName(clientFileName)))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(clientFileName));
                }
                webClient.DownloadFile(uri, clientFileName);
            }
        }

        /// <summary>
        /// 异步下载
        /// </summary>
        /// <param name="manifest"></param>
        public void DownloadAsync(Manifest manifest)
        {
            Init(manifest);
            DownloadAsync(manifest,defaultTaskId);
        }

        /// <summary>
        /// 异步下载并指定任务Id
        /// </summary>
        /// <param name="manifest"></param>
        /// <param name="taskId"></param>
        public void DownloadAsync(Manifest manifest,object taskId)
        {
            AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId);
            lock (userStateToLifetime.SyncRoot)
            {
                if (userStateToLifetime.Contains(taskId))
                {
                    throw new ArgumentException("参数taskId必须是唯一的", "taskId");
                }
                userStateToLifetime[taskId] = asyncOp;
            }
            WorkerEventHandler workerDelegate = new WorkerEventHandler(DownloadWorker);
            workerDelegate.BeginInvoke(asyncOp, null, null);
        }

        private void Init(Manifest manifest)
        {
            this.manifest = manifest;
            webClient.BaseAddress = manifest.ManifestFiles.BaseUrl;
            webClient.Credentials = CredentialCache.DefaultCredentials;
            webClient.Encoding = Encoding.UTF8;
        }

        /// <summary>
        /// 异步下载方法
        /// </summary>
        /// <param name="asyncOp"></param>
        private void DownloadWorker(AsyncOperation asyncOp)
        {
            current = asyncOp;
            if (!TaskCanceled(asyncOp.UserSuppliedState))
            {
                try
                {
                    webClient.DownloadFileCompleted += new AsyncCompletedEventHandler(webClient_DownloadFileCompleted);
                    webClient.DownloadProgressChanged += new DownloadProgressChangedEventHandler(webClient_DownloadProgressChanged);
                    foreach (var file in manifest.ManifestFiles.Files)
                    {
                        string serverFileName = Path.Combine(manifest.ManifestFiles.BaseUrl, file.Source);
                        string clientFileName = Path.Combine(tempPath, file.Source);
                        Uri uri = new Uri(serverFileName);
                        if (!Directory.Exists(Path.GetDirectoryName(clientFileName)))
                        {
                            Directory.CreateDirectory(Path.GetDirectoryName(clientFileName));
                        }
                        while (webClient.IsBusy)
                        {
                            //阻塞异步下载
                        }
                        if (!cancel)
                        {
                            webClient.DownloadFileAsync(uri, clientFileName, file.Source);
                        }
                    }
                }
                catch (Exception ex)
                {
                    DownloadErrorEventArgs e = new DownloadErrorEventArgs();
                    e.Error = ex;
                    e.Manifest = manifest;
                    OnDownloadError(e);
                }
            }
        }

        /// <summary>
        /// 异步完成方法
        /// </summary>
        /// <param name="exception"></param>
        /// <param name="canceled"></param>
        /// <param name="asyncOp"></param>
        private void CompletionMethod(Exception exception, bool canceled, AsyncOperation asyncOp)
        {
            if (!canceled)
            {
                lock (userStateToLifetime.SyncRoot)
                {
                    userStateToLifetime.Remove(asyncOp.UserSuppliedState);
                }
            }
            DownloadCompleteEventArgs e = new DownloadCompleteEventArgs(exception, canceled, asyncOp.UserSuppliedState);
            e.Manifest = manifest;
            asyncOp.PostOperationCompleted(onCompletedDelegate, e);
            current = null;
        }

        /// <summary>
        /// 异步下载进度事件（仅对于单个文件）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void webClient_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
        {
            DownloadProgressEventArgs args = new DownloadProgressEventArgs(e.ProgressPercentage, e.UserState);
            args.BytesReceived = e.BytesReceived;
            args.FileName = e.UserState.ToString();
            args.TotalBytesToReceive = e.TotalBytesToReceive;
            if (current != null)
            {
                current.Post(onProgressReportDelegate, args);
            }
        }

        /// <summary>
        /// 异步下载完成事件（仅对于单个文件）
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void webClient_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
        {
            fileCount++;
            if (fileCount == manifest.ManifestFiles.Files.Length)
            {
                this.CompletionMethod(e.Error, TaskCanceled(current.UserSuppliedState), current);
            }
        }

        /// <summary>
        /// 取消异步下载
        /// </summary>
        public void CancelAsync()
        {
            CancelAsync(defaultTaskId);
        }

        /// <summary>
        /// 取消异步下载
        /// </summary>
        public void CancelAsync(object taskId)
        {
            webClient.CancelAsync();
            cancel = true;
            current = null;
            AsyncOperation asyncOp = userStateToLifetime[taskId] as AsyncOperation;
            if (asyncOp != null)
            {
                lock (userStateToLifetime.SyncRoot)
                {
                    userStateToLifetime.Remove(taskId);
                }
            }
        }

        private bool TaskCanceled(object taskId)
        {
            return cancel || (userStateToLifetime[taskId] == null);
        }
        
        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose(disposing);
        }

        private void DoDownloadCompleted(object operationState)
        {
            DownloadCompleteEventArgs e = operationState as DownloadCompleteEventArgs;
            OnDownloadCompleted(e);
        }

        private void ReportProgress(object state)
        {
            DownloadProgressEventArgs e = state as DownloadProgressEventArgs;
            OnDownloadProgressChanged(e);
        }
    }

更新文件

也就是把下载的文件覆盖到客户端安装的目录，代码如下：

事件参数类

 /// <summary>
    /// 文件复制进度报告事件参数
    /// </summary>
    public class FileCopyProgressChangedEventArgs : ProgressChangedEventArgs
    {
        public FileCopyProgressChangedEventArgs(int progressPercentage, object userState)
            : base(progressPercentage, userState)
        {
        }

        /// <summary>
        /// 当前复制的字节数
        /// </summary>
        public double BytesToCopy { get; set; }

        /// <summary>
        /// 当前复制操作中的字节总数
        /// </summary>
        public double TotalBytesToCopy { get; set; }

        /// <summary>
        /// 当前复制的源文件名
        /// </summary>
        public string SourceFileName { get; set; }

        /// <summary>
        /// 当前复制的目标文件名
        /// </summary>
        public string TargetFileName { get; set; }

        public Manifest Manifest { get; set; }
    }

    /// <summary>
    /// 文件复制完成事件参数
    /// </summary>
    public class FileCopyCompletedEventArgs : AsyncCompletedEventArgs
    {
        public FileCopyCompletedEventArgs(Exception error, bool cancelled, object userState)
            : base(error, cancelled, userState)
        {
        }

        public Manifest Manifest { get; set; }
    }

    public class FileCopyErrorEventArgs : EventArgs
    {
        public Exception Error { get; set; }

        public Manifest Manifest { get; set; }
    }

文件复制类，可以使用异步复制，异步复制提供了事件通知的机制，即可以有进度报告，文件复制也是一个组件类

 /// <summary>
    /// 文件复制组件类
    /// </summary>
    public class FileCopyClass : Component
    {
        private object defaultTaskId = new object();
        private int writeFileLength = 1024 * 64;

        private delegate void WorkerEventHandler(Manifest manifest, string sourcePath, AsyncOperation asyncOp);

        private SendOrPostCallback onProgressReportDelegate;
        private SendOrPostCallback onCompletedDelegate;

        private HybridDictionary userStateToLifetime = new HybridDictionary();

        private System.ComponentModel.Container components = null;

        #region Public events

        /// <summary>
        /// 文件复制进度事件
        /// </summary>
        public event EventHandler<FileCopyProgressChangedEventArgs> FileCopyProgressChanged;
        /// <summary>
        /// 文件复制完成事件
        /// </summary>
        public event EventHandler<FileCopyCompletedEventArgs> FileCopyCompleted;

        public event EventHandler<FileCopyErrorEventArgs> FileCopyError;

        #endregion

        #region Construction and destruction

        public FileCopyClass(IContainer container)
        {
            container.Add(this);
            InitializeComponent();
            InitializeDelegates();
        }

        public FileCopyClass()
        {
            InitializeComponent();
            InitializeDelegates();
        }

        protected virtual void InitializeDelegates()
        {
            onProgressReportDelegate = new SendOrPostCallback(ReportProgress);
            onCompletedDelegate = new SendOrPostCallback(CopyCompleted);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose(disposing);
        }

        #endregion

        #region 实现

        public int WriteFileLength
        {
            set
            {
                writeFileLength = value;
            }
        }

        public void Copy(Manifest manifest, string sourcePath)
        {
            string[] sourceFiles = null;
            string[] targetFiles = null;
            GetFiles(manifest, sourcePath, out sourceFiles, out targetFiles);
            for (int i = 0; i < sourceFiles.Length; i++)
            {
                if (!Directory.Exists(Path.GetDirectoryName(targetFiles[i])))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(targetFiles[i]));
                }
                File.Copy(sourceFiles[i], targetFiles[i], true);
            }
        }

        public void CopyAsync(Manifest manifest, string sourcePath)
        {
            CopyAsync(manifest, sourcePath, defaultTaskId);
        }

        public void CopyAsync(Manifest manifest, string sourcePath, object taskId)
        {
            AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(taskId);
            lock (userStateToLifetime.SyncRoot)
            {
                if (userStateToLifetime.Contains(taskId))
                {
                    throw new ArgumentException("参数taskId必须是唯一的", "taskId");
                }
                userStateToLifetime[taskId] = asyncOp;
            }

            WorkerEventHandler workerDelegate = new WorkerEventHandler(FileCopyWorker);
            workerDelegate.BeginInvoke(manifest, sourcePath, asyncOp, null, null);
        }

        private bool TaskCanceled(object taskId)
        {
            return (userStateToLifetime[taskId] == null);
        }

        public void CancelAsync()
        {
            CancelAsync(defaultTaskId);
        }

        public void CancelAsync(object taskId)
        {
            AsyncOperation asyncOp = userStateToLifetime[taskId] as AsyncOperation;
            if (asyncOp != null)
            {
                lock (userStateToLifetime.SyncRoot)
                {
                    userStateToLifetime.Remove(taskId);
                }
            }
        }

        private void FileCopyWorker(Manifest manifest, string sourcePath, AsyncOperation asyncOp)
        {
            Exception exception = null;
            FileCopyProgressChangedEventArgs e = null;
            Stream rStream = null;
            Stream wStream = null;
            double writeBytes = 0;
            string[] sourceFiles = null; 
            string[] targetFiles = null;
            GetFiles(manifest, sourcePath,out sourceFiles,out targetFiles);
            if (!TaskCanceled(asyncOp.UserSuppliedState))
            {
                try
                {
                    double totalBytes = GetFileLength(sourceFiles);
                    byte[] buffer = new byte[writeFileLength];
                    int len = 0;
                    int offset = 0;
                    for (int i = 0; i < sourceFiles.Length; i++)
                    {
                        try
                        {
                            if (!Directory.Exists(Path.GetDirectoryName(targetFiles[i])))
                            {
                                Directory.CreateDirectory(Path.GetDirectoryName(targetFiles[i]));
                            } 
                            rStream = new FileStream(sourceFiles[i], FileMode.Open, FileAccess.Read, FileShare.None);
                            wStream = new FileStream(targetFiles[i], FileMode.Create, FileAccess.Write, FileShare.None);
                            while ((len = rStream.Read(buffer, offset, writeFileLength)) > 0)
                            {
                                wStream.Write(buffer, offset, len);
                                writeBytes += len;
                                e = new FileCopyProgressChangedEventArgs((int)(writeBytes / totalBytes * 100), asyncOp.UserSuppliedState);
                                e.SourceFileName = sourceFiles[i];
                                e.TargetFileName = targetFiles[i];
                                e.TotalBytesToCopy = totalBytes;
                                e.BytesToCopy = len;
                                e.Manifest = manifest;
                                asyncOp.Post(this.onProgressReportDelegate, e);
                                Thread.Sleep(1);
                            }
                        }
                        finally
                        {
                            DisposeStream(wStream);
                            DisposeStream(rStream);
                        }
                    }
                }
                catch (Exception ex)
                {
                    exception = ex;
                    OnFileCopyError(new FileCopyErrorEventArgs() { Error = ex, Manifest = manifest });
                }
            }
            this.CompletionMethod(manifest, exception, TaskCanceled(asyncOp.UserSuppliedState), asyncOp);
        }

        private void GetFiles(Manifest manifest, string sourcePath,out string[] sourceFiles,out string[] targetFiles)
        {
            sourceFiles = new string[manifest.ManifestFiles.Files.Length];
            targetFiles = new string[manifest.ManifestFiles.Files.Length];
            string path = Path.GetFullPath(manifest.Application.Location);
            for (int i = 0; i < manifest.ManifestFiles.Files.Length; i++)
            {
                sourceFiles[i] = Path.Combine(sourcePath, manifest.ManifestFiles.Files[i].Source);
                targetFiles[i] = Path.Combine(path, manifest.ManifestFiles.Files[i].Source);
            }
        }

        private void DisposeStream(Stream stream)
        {
            if (stream != null)
            {
                stream.Flush();
                stream.Close();
                stream.Dispose();
            }
        }

        private double GetFileLength(string[] sourceFiles)
        {
            double bytes = 0;
            foreach (var file in sourceFiles)
            {
                FileInfo fileInfo = new FileInfo(file);
                bytes += fileInfo.Length;
            }
            return bytes;
        }

        private void CopyCompleted(object operationState)
        {
            FileCopyCompletedEventArgs e = operationState as FileCopyCompletedEventArgs;

            OnFileCopyCompleted(e);
        }

        private void ReportProgress(object state)
        {
            FileCopyProgressChangedEventArgs e = state as FileCopyProgressChangedEventArgs;

            OnProgressChanged(e);
        }

        protected void OnFileCopyCompleted(FileCopyCompletedEventArgs e)
        {
            if (FileCopyCompleted != null)
            {
                FileCopyCompleted(this, e);
            }
        }

        protected void OnProgressChanged(FileCopyProgressChangedEventArgs e)
        {
            if (FileCopyProgressChanged != null)
            {
                FileCopyProgressChanged(this, e);
            }
        }

        protected void OnFileCopyError(FileCopyErrorEventArgs e)
        {
            if (FileCopyError != null)
            {
                FileCopyError(this, e);
            }
        }

        private void CompletionMethod(Manifest manifest, Exception exception, bool canceled, AsyncOperation asyncOp)
        {
            if (!canceled)
            {
                lock (userStateToLifetime.SyncRoot)
                {
                    userStateToLifetime.Remove(asyncOp.UserSuppliedState);
                }
            }

            FileCopyCompletedEventArgs e = new FileCopyCompletedEventArgs(exception, canceled, asyncOp.UserSuppliedState);
            e.Manifest = manifest;
            asyncOp.PostOperationCompleted(onCompletedDelegate, e);
        }

        #endregion

        private void InitializeComponent()
        {
            components = new System.ComponentModel.Container();
        }
    }

 好了，基本的代码已经完成了，其他都是客户端调用的代码，客户端有2个exe程序，一个是主程序，另外一个是更新程序，所以使用2个exe的原因是，主程序在打开的情况是无法进行更新的，就是文件不能被覆盖，那么主程序只要引用上面写的程序的dll，以及一个配置文件，配置文件的名称在程序写死了的，默认是在exe目录，名称为updateconfiguration.config，主程序只要调用UpdateClass类的CheckForUpdates方法就可以了

Demo

下面说下整体的部署方式

服务器：一个配置文件，记录更新的文件，记录的文件目录一定是存在的，否则会出现404错误

客户端：主程序+更新程序+配置文件，即把更新程序编译后的exe打包到主程序中，

以上程序进行了简单的测试，如果您下载使用了出现了问题，请及时联系我。

作者：风雨彩虹

　　　　

出处：http://www.cnblogs.com/liubiaocai/

　　　　

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。