winform c# 自动更新

 

winform  c# 自动更新,首先预览下截图

 

自动更新一般分3部分：

1、发现更新

2、下载文件

3、复制文件

 http://www.cnblogs.com/liubiaocai/archive/2011/07/18/2109183.html

下面对以上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对应的实体类

View Code

[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类，异步下载有事件通知，详见源码：

事件类

View Code

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; }
    }

 下载代码

 

View Code

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);
        }
    }

 

源代码下载：  http://files.cnblogs.com/liubiaocai/Updater.rar