c# 如何实现自动更新程序

主要功能介绍

实现文件的自动更新。主要功能:

  1. 支持整包完全更新,即客户端只需输入一个服务器地址,即可下载所有文件。
  2. 支持增量更新,即只更新指定的某几个文件。
  3. 支持自动更新程序的更新

更新界面如图:

客户端

main方法入口

/// <summary>
 /// 应用程序的主入口点。
 /// </summary>
 [STAThread]
 static void Main()
 {
  //在主程序中 更新替换自动升级程序
  //ReplaceAutoUpgrade();

  bool isEnterMain = false;
  try
  {
  //设置默认更新地址,如果不设置,后面会从配置文件,或界面上进行设置
  UpgradeHelper.Instance.DefaultUrl = "http://localhost:17580";
  if (UpgradeHelper.Instance.Local_UpgradeModel != null)
  {
   UpgradeHelper.Instance.UpgradeUrl = UpgradeHelper.Instance.Local_UpgradeModel.UpgradeUrl;
  }

  if (UpgradeHelper.Instance.WillUpgrades.Count == 0 && UpgradeHelper.Instance.Local_UpgradeModel != null)
  {
   //没有待更新,并且本地版本信息文件不为空,则直接启动主程序
   bool isSucced = UpgradeHelper.StartRunMain(UpgradeHelper.Instance.Local_UpgradeModel.RunMain);
   if (isSucced)
   {
   Application.Exit();
   }
   else
   {
   //清理版本信息 以便重新检测版本
   UpgradeHelper.Instance.ClearUpgradeModel();
   isEnterMain = true;
   }
  }
  else
  {
   isEnterMain = true;
  }
  }
  catch (Exception ex)
  {
  isEnterMain = true;
  MessageBox.Show("运行更新程序异常:\n" + ex.Message, "错误提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
  }

  if (isEnterMain)
  {
  //进入更新主界面
  Application.EnableVisualStyles();
  Application.SetCompatibleTextRenderingDefault(false);
  Application.Run(new FrmUpdate());
  }
 }

主窗体代码

public partial class FrmUpdate: Form
{
 /// <summary>
 /// 构造函数
 /// </summary>
 /// <param name="tempPath"></param>
 /// <param name="updateFiles"></param>
 public FrmUpdate()
 {
  InitializeComponent();
 }
 /// <summary>
 /// 窗体加载事件
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void FrmUpdate_Load(object sender, EventArgs e)
 {
  try
  {
  //加载服务器地址
  txtHostUrl.Text = UpgradeHelper.Instance.UpgradeUrl;
  BeginUpgrade();
  }
  catch(Exception ex)
  {
  Output("初始化异常:" + ex.Message);
  }
 }
 /// <summary>
 /// 手动更新
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void butBegin_Click(object sender, EventArgs e)
 {
 try
 {
  if(string.IsNullOrWhiteSpace(txtHostUrl.Text))
  {
  Output("请先输入服务器地址!");
  return;
  }
  UpgradeHelper.Instance.UpgradeUrl = txtHostUrl.Text.Trim();
  //清理版本信息 以便重新检测版本
  UpgradeHelper.Instance.ClearUpgradeModel();
  BeginUpgrade();
 }
 catch(Exception ex)
 {
  Output("更新异常:" + ex.Message);
 }
 }
 private void BeginUpgrade()
 {
  try
  {
  if(string.IsNullOrWhiteSpace(UpgradeHelper.Instance.UpgradeUrl))
  {
   return;
  }
  if(!(UpgradeHelper.Instance.UpgradeUrl.StartsWith("http://") || UpgradeHelper.Instance.UpgradeUrl.StartsWith("https://")))
  {
   Output("错误的服务器地址,地址必须以http://或者https://开头");
   return;
  }
  //判断是否有更新
  if(UpgradeHelper.Instance.WillUpgrades.Count > 0 && UpgradeHelper.Instance.Server_UpgradeModel != null)
  {
   SetWinControl(false);
   //杀死主进程
   UpgradeHelper.KillProcess(UpgradeHelper.Instance.Server_UpgradeModel.RunMain);
   RunUpgrade(); //启动更新
  }
  }
  catch(Exception ex)
  {
  Output("更新异常:" + ex.Message);
  }
 }
 /// <summary>
 /// 启动更新
 /// </summary>
 private void RunUpgrade()
 {
  //启动更新
  SetCaption(string.Format("共需更新文件{0}个,已更新0个。正在更新下列文件:", UpgradeHelper.Instance.WillUpgrades.Count));
  Task.Factory.StartNew(() =>
  {
  string curFile = "";
  try
  {
   int idx = 0;
   foreach(KeyValuePair < string, string > item in UpgradeHelper.Instance.WillUpgrades)
   {
    curFile = item.Key;
    string filePath = string.Format("{0}\\{1}", Application.StartupPath, item.Key);
    if(item.Key.IndexOf(UpgradeHelper.Instance.Server_UpgradeModel.AutoUpgrade) >= 0)
    {
    //如果当前文件为更新主程序
    filePath = string.Format("{0}\\AutoUpgradeTemp\\{1}", Application.StartupPath, item.Key);
    }
    string directory = Path.GetDirectoryName(filePath);
    if(!Directory.Exists(directory))
    {
    Directory.CreateDirectory(directory);
    }
    MyWebResquest.DownloadFile(UpgradeHelper.Instance.UpgradeUrl, item.Key, filePath);
    idx++;
    SetCaption(string.Format("共需更新文件{0}个,已更新{1}个。更新文件列表:", UpgradeHelper.Instance.WillUpgrades.Count, idx));
    Output(string.Format("更新文件{0}完成", curFile));
   }
   //保存版本文件
   File.WriteAllText(UpgradeHelper.Instance.Local_UpgradeXmlPath, UpgradeHelper.Instance.Server_UpgradeXml);
   SetCaption(string.Format("更新完成,共更新文件{0}个", UpgradeHelper.Instance.WillUpgrades.Count));
   Output(string.Format("更新完成,共更新文件{0}个", UpgradeHelper.Instance.WillUpgrades.Count));
   //下载完成后处理
   UpgradeHelper.StartRunMain(UpgradeHelper.Instance.Server_UpgradeModel.RunMain);
   //退出当前程序
   ExitCurrent();
  }
  catch(Exception ex)
  {
   Output(string.Format("更新文件{0}异常:{1}", curFile, ex.Message));
   SetWinControl(true);
  }
  });
 }
 /// <summary>
 /// 设置界面控件是否可用
 /// </summary>
 /// <param name="enabled"></param>
 private void SetWinControl(bool enabled)
 {
  if(this.InvokeRequired)
  {
  Action < bool > d = new Action < bool > (SetWinControl);
  this.Invoke(d, enabled);
  }
  else
  {
  txtHostUrl.Enabled = enabled;
  butBegin.Enabled = enabled;
  }
 }
 /// <summary>
 /// 退出当前程序
 /// </summary>
 private void ExitCurrent()
 {
 if(this.InvokeRequired)
 {
  Action d = new Action(ExitCurrent);
  this.Invoke(d);
 }
 else
 {
  Application.Exit();
 }
 }#
 region 日志输出
 /// <summary>
 /// 设置跟踪状态
 /// </summary>
 /// <param name="caption"></param>
 private void SetCaption(string caption)
 {
  if(this.lblCaption.InvokeRequired)
  {
  Action < string > d = new Action < string > (SetCaption);
  this.Invoke(d, caption);
  }
  else
  {
  this.lblCaption.Text = caption;
  }
 }
 /// <summary>
 /// 设置跟踪状态
 /// </summary>
 /// <param name="caption"></param>
 private void Output(string log)
 {
 if(this.txtLog.InvokeRequired)
 {
  Action < string > d = new Action < string > (Output);
  this.Invoke(d, log);
 }
 else
 {
  txtLog.AppendText(string.Format("{0}:{1}\r\n", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), log));
  txtLog.ScrollToCaret();
 }
 }
 private void ClearOutput()
 {
 if(this.txtLog.InvokeRequired)
 {
  Action d = new Action(ClearOutput);
  this.Invoke(d);
 }
 else
 {
  txtLog.Text = "";
 }
 }#
 endregion
 private void FrmUpdate_FormClosing(object sender, FormClosingEventArgs e)
 {
 if(e.CloseReason == CloseReason.UserClosing)
 {
  if(MessageBox.Show("升级未完成,退出后将导致软件无法正常使用,你确定要退出吗?", "退出提示", MessageBoxButtons.YesNo) != System.Windows.Forms.DialogResult.Yes)
  {
  //取消"关闭窗口"事件
  e.Cancel = true;
  }
 }
 }
}

更新帮助类

/// <summary>
/// 更新帮助类
/// </summary>
public class UpgradeHelper
{
 /// <summary>
 /// 默认服务器地址
 /// 在配置文件中未找到地址时,使用此地址进行更新
 /// </summary>
 public string DefaultUrl
 {
 get;
 set;
 }
 public string _upgradeUrl;
 /// <summary>
 /// 获取或设置服务器地址
 /// </summary>
 public string UpgradeUrl
 {
 get
 {
  if(string.IsNullOrWhiteSpace(_upgradeUrl))
  {
  return DefaultUrl;
  }
  return _upgradeUrl;
 }
 set
 {
  _upgradeUrl = value;
 }
 }
 /// <summary>
 /// 本地配置文件路径
 /// </summary>
 public string Local_UpgradeXmlPath = Path.Combine(Application.StartupPath, "UpgradeList.xml");
 private UpgradeModel _local_UpgradeModel;
 /// <summary>
 /// 本地版本信息
 /// </summary>
 public UpgradeModel Local_UpgradeModel
 {
 get
 {
  try
  {
  if(_local_UpgradeModel == null)
  {
   if(File.Exists(Local_UpgradeXmlPath))
   {
   _local_UpgradeModel = new UpgradeModel();
   _local_UpgradeModel.LoadUpgrade(File.ReadAllText(Local_UpgradeXmlPath));
   }
  }
  return _local_UpgradeModel;
  }
  catch(Exception ex)
  {
  throw new Exception(string.Format("获取本地版本文件UpgradeList.xml异常:{0}", ex.Message));
  }
 }
 }
 private UpgradeModel _server_UpgradeModel;
 /// <summary>
 /// 服务器版本信息
 /// </summary>
 public UpgradeModel Server_UpgradeModel
 {
 get
 {
  try
  {
  if(_server_UpgradeModel == null && !string.IsNullOrWhiteSpace(UpgradeUrl))
  {
   string resXml = MyWebResquest.GetUpgradeList(UpgradeUrl);
   if(!string.IsNullOrWhiteSpace(resXml))
   {
   _server_UpgradeModel = new UpgradeModel();
   _server_UpgradeModel.LoadUpgrade(resXml);
   _server_UpgradeXml = resXml;
   }
  }
  return _server_UpgradeModel;
  }
  catch(Exception ex)
  {
  throw new Exception(string.Format("获取服务端版本文件UpgradeList.xml异常:{0}", ex.Message));
  }
 }
 }
 private string _server_UpgradeXml;
 /// <summary>
 /// 服务端版本配置xml
 /// </summary>
 public string Server_UpgradeXml
 {
 get
 {
  return _server_UpgradeXml;
 }
 }
 private Dictionary < string, string > _willUpgrades;
 /// <summary>
 /// 待更新文件列表,如果为0,则表示不需要更新
 /// </summary>
 public Dictionary < string, string > WillUpgrades
 {
  get
  {
  if(_willUpgrades == null)
  {
   _willUpgrades = new Dictionary < string, string > ();
   //如果服务器端未获取到版本信息 则不更新
   if(Server_UpgradeModel != null)
   {
   if(Local_UpgradeModel == null) //本地版本信息为空 全部更新
   {
    _willUpgrades = Server_UpgradeModel.DictFiles;
   }
   else
   {
    //对比需要更新的文件
    foreach(var item in Server_UpgradeModel.DictFiles)
    {
    //如果找到
    if(Local_UpgradeModel.DictFiles.ContainsKey(item.Key))
    {
     //如果版本不匹配
     if(Local_UpgradeModel.DictFiles[item.Key] != item.Value)
     {
     _willUpgrades.Add(item.Key, item.Value);
     }
    }
    else
    {
     //没有找到
     _willUpgrades.Add(item.Key, item.Value);
    }
    }
   }
   }
  }
  return _willUpgrades;
  }
 }
 /// <summary>
 /// 清空版本信息
 /// </summary>
 public void ClearUpgradeModel()
 {
 if(File.Exists(Local_UpgradeXmlPath))
 {
  try
  {
  string xmlStr = File.ReadAllText(Local_UpgradeXmlPath);
  XmlDocument xmlDoc = new XmlDocument();
  xmlDoc.LoadXml(xmlStr);
  XmlNode node = xmlDoc.SelectSingleNode("Upgrade/Files");
  if(node != null && node.ChildNodes.Count > 0)
  {
   node.RemoveAll();
  }
  File.WriteAllText(UpgradeHelper.Instance.Local_UpgradeXmlPath, xmlDoc.InnerXml);
  }
  catch(Exception)
  {}
 }
 _local_UpgradeModel = null;
 _server_UpgradeModel = null;
 _willUpgrades = null;
 }#
 region 单例对象
 private static UpgradeHelper _instance;
 /// <summary>
 /// 单例对象
 /// </summary>
 public static UpgradeHelper Instance
 {
 get
 {
  if(_instance == null)
  {
  _instance = new UpgradeHelper();
  //初始化本地配置文件,以及服务器地址
  if(_instance.Local_UpgradeModel != null)
  {
   _instance.UpgradeUrl = _instance.Local_UpgradeModel.UpgradeUrl;
  }
  }
  return _instance;
 }
 }#
 endregion# region 静态方法
 /// <summary>
 /// 启动主程序
 /// </summary>
 /// <param name="fileName"></param>
 public static bool StartRunMain(string fileName)
 {
  string fullPath = fileName;
  try
  {
  Process process = GetProcess(fileName);
  if(process != null) //以及存在运行中的主进程
  {
   return true;
  }
  fullPath = string.Format("{0}\\{1}", Application.StartupPath, fileName);
  ProcessStartInfo main = new ProcessStartInfo(fullPath);
  Process.Start(fullPath);
  return true;
  }
  catch(Exception ex)
  {
  MessageBox.Show(string.Format("主程序{0}调用失败:\n{1}", fullPath, ex.Message), "错误提示", MessageBoxButtons.OK, MessageBoxIcon.Error);
  }
  return false;
 }
 /// <summary>
 /// 杀死进程
 /// </summary>
 /// <param name="process"></param>
 public static void KillProcess(string processName)
 {
  if(string.IsNullOrWhiteSpace(processName)) return;
  processName = processName.ToLower();
  processName = processName.Replace(".exe", "");
  //杀死主进程
  Process[] processes = Process.GetProcesses();
  foreach(Process process in processes)
  {
  if(!string.IsNullOrWhiteSpace(process.ProcessName))
  {
   if(process.ProcessName.ToLower() == processName)
   {
   process.Kill();
   }
  }
  }
 }
 /// <summary>
 /// 获取进程
 /// </summary>
 /// <param name="pName"></param>
 /// <returns></returns>
 public static Process GetProcess(string pName)
 {
 if(string.IsNullOrWhiteSpace(pName)) return null;
 pName = pName.ToLower();
 pName = pName.Replace(".exe", "");
 //杀死主进程
 Process[] processes = Process.GetProcesses();
 foreach(Process process in processes)
 {
  if(!string.IsNullOrWhiteSpace(process.ProcessName))
  {
  if(process.ProcessName.ToLower() == pName)
  {
   return process;
  }
  }
 }
 return null;
 }#
 endregion
}

版本xml文件解析

public class UpgradeModel
{
 /// <summary>
 /// 初始化对象
 /// </summary>
 /// <param name="xml"></param>
 public void LoadUpgrade(string xml)
 {
 XmlDocument xmlDoc = new XmlDocument();
 xmlDoc.LoadXml(xml);
 //读取UpgradeUrl
 XmlNode node = xmlDoc.SelectSingleNode("//UpgradeUrl");
 if(node != null)
 {
  this.UpgradeUrl = node.InnerText;
 }
 //读取RunMain
 node = xmlDoc.SelectSingleNode("//RunMain");
 if(node != null)
 {
  this.RunMain = node.InnerText;
 }
 //读取RunMain
 node = xmlDoc.SelectSingleNode("//AutoUpgrade");
 if(node != null)
 {
  this.AutoUpgrade = node.InnerText;
 }
 //读取Files
 node = xmlDoc.SelectSingleNode("Upgrade/Files");
 this.DictFiles = new Dictionary < string, string > ();
 if(node != null && node.ChildNodes.Count > 0)
 {
  foreach(XmlNode item in node.ChildNodes)
  {
  if(item.Name != "#comment")
  {
   string name = GetNodeAttrVal(item, "Name");
   string version = GetNodeAttrVal(item, "Version");
   if(!this.DictFiles.ContainsKey(name))
   {
   this.DictFiles.Add(name, version);
   }
  }
  }
 }
 }
 private string GetNodeAttrVal(XmlNode node, string attr)
 {
  if(node != null && node.Attributes != null && node.Attributes[attr] != null)
  {
  string val = node.Attributes[attr].Value;
  if(!string.IsNullOrWhiteSpace(val))
  {
   return val.Trim();
  }
  return val;
  }
  return string.Empty;
 }
 /// <summary>
 /// 服务器地址
 /// </summary>
 public string UpgradeUrl
 {
 get;
 set;
 }
 /// <summary>
 /// 更新完成后运行的主程序名称
 /// </summary>
 public string RunMain
 {
 get;
 set;
 }
 /// <summary>
 /// 更新程序名称
 /// </summary>
 public string AutoUpgrade
 {
 get;
 set;
 }
 /// <summary>
 /// 文件列表
 /// string 文件名
 /// string 版本号
 /// </summary>
 public Dictionary < string, string > DictFiles
 {
 get;
 set;
 }
}

服务端

服务端主Xml版本文件,包含所有的项目文件,客户端根据每个文件的版本号进行判断是否需要更新。如果需只更新某几个文件,则将对应文件的版本号更改只更高的版本号即可

版本xml文件

<?xml version="1.0" encoding="utf-8" ?>
<Upgrade>
 <!--服务器地址-->
 <UpgradeUrl>http://localhost:17580</UpgradeUrl>
 <!--更新完成后运行的主程序名称-->
 <RunMain>ClientMain.exe</RunMain>
 <!--更新程序名称-->
 <AutoUpgrade>AutoUpgrade.exe</AutoUpgrade>
 <Files>
 <!--更新文件列表,以Version为标志,当Version改变时,客户端启动会自动更新。子路径格式:\image\index.jpg-->
 <File Version="01" Name="\image\index.jpg" />
 <File Version="01" Name="ClientMain.exe" />
 <File Version="01" Name="AutoUpgrade.exe" />
 </Files>
</Upgrade>

服务端主要提供连个可以通过Http的get或post访问的路径。一个用于获取版本Xml文件内容,一个用于下载指定文件的路径。以下代码示例通过asp.net mvc进行实现。大家可以根据自己技术方式参照实现。

自动升级服务Controller

/// <summary>
/// 自动升级服务
/// </summary>
public class UpgradeController: Controller
{
 //
 // GET: /Upgrade/
 /// <summary>
 /// 获取更新文件列表
 /// </summary>
 /// <returns></returns>
 public object UpgradeList()
 {
  string cacheKey = "Upgrade_UpgradeList.xml";
  string resStr = CommonLibrary.CacheClass.GetCache < string > (cacheKey);
  if(string.IsNullOrWhiteSpace(resStr))
  {
  string fileName = Server.MapPath(@"~\App_Data\UpgradeList.xml");
  if(System.IO.File.Exists(fileName))
  {
   resStr = System.IO.File.ReadAllText(fileName);
   CommonLibrary.CacheClass.SetCacheMins(cacheKey, resStr, 1);
  }
  }
  return resStr;
 }
 /// <summary>
 /// 生成更新文件
 /// </summary>
 /// <returns></returns>
 public object Create()
 {
  UpgradeFileManager.CreateFiles(Server.MapPath("/App_Data"));
  return "ok";
 }
 /// <summary>
 /// 下载文件
 /// </summary>
 /// <param name="fileName"></param>
 /// <returns></returns>
 public object DownloadFile()
 {
  string fileName = PageRequest.GetString("fileName");
  fileName = Server.MapPath(string.Format(@"~\App_Data\{0}", fileName));
  return File(fileName, "application/octet-stream");
 }
 /// <summary>
 /// 异常处理
 /// </summary>
 /// <param name="filterContext"></param>
 protected override void OnException(ExceptionContext filterContext)
 {
 filterContext.HttpContext.Response.StatusCode = 400;
 filterContext.Result = Content(filterContext.Exception.GetBaseException().Message);
 filterContext.ExceptionHandled = true;
 }
}

版本文件自动生成帮助类

/// <summary>
/// 此类主要作用,对于项目文件非常多,自己手动编辑很麻烦,可以采用此方法,指定目录自动生成初始化的版本文件
/// </summary>
public class UpgradeFileManager
{
 /// <summary>
 /// 创建版本文件
 /// </summary>
 /// <param name="path"></param>
 public static void CreateFiles(string path)
 {
  List < string > dirList = new List < string > ();
  GetAllDirt(path, dirList); //获取所有目录
  dirList.Add(path);
  System.Text.StringBuilder xml = new System.Text.StringBuilder();
  xml.AppendLine("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
  xml.AppendLine(" <Files>");
  foreach(var diry in dirList)
  {
  string[] files = Directory.GetFiles(diry);
  foreach(string filePath in files)
  {
   FileInfo info = new FileInfo(filePath);
   string name = filePath.Replace(path, "");
   if(info.Directory.FullName == path)
   {
   name = name.Remove(0, 1);
   }
   xml.AppendLine(string.Format(" <File Version=\"1\" Name=\"{0}\" />", name));
  }
  }
  xml.AppendLine("</Files>");
  using(StreamWriter sw = new StreamWriter(Path.Combine(path, "UpgradeList_Temp.xml")))
  {
  sw.Write(xml);
  sw.Close();
  }
 }
 /// <summary>
 /// 获取所有子目录
 /// </summary>
 /// <param name="curDir"></param>
 /// <param name="list"></param>
 private static void GetAllDirt(string curDir, List < string > list)
 {
 string[] dirs = Directory.GetDirectories(curDir);
 if(dirs.Length > 0)
 {
  foreach(string item in dirs)
  {
  list.Add(item);
  GetAllDirt(item, list);
  }
 }
 }
}

结语

源代码托管于GitHub,供大伙学习参考,项目地址:https://github.com/keguoquan/AutoUpgrade。感兴趣或觉得不错的望赏个star,不胜感激!

若能顺手点个赞,更加感谢!

以上就是用c# 自动更新程序的详细内容,更多关于c# 自动更新程序的资料请关注我们其它相关文章!

(0)

相关推荐

  • c# Winform 程序自动更新实现方法

    Winform程序自动更新我也是第一次做,网上找了自动更新的源码,后来又根据在网上看到的一些方法,自己试了很久,最终还是有写错误,所以花了钱让别人帮忙调试成功的,下面是我自己捣腾出来的,方便大家借鉴,如果有什么错误的地方欢迎指正. 1.由于我是通过服务器的IIS发布自动更新的,更新之前先手动把程序复制到IIS服务器的目录下面,做一些更改,客户端才能正常自动更新.所以第一步是不熟IIS服务器(本人系统windows8): 按照上面的方式,选了之后点确定,系统会自动添加这些内容,然后: 网站建立好了

  • C# Winform 自动更新程序实例详解

    本文实例为大家分享了C# Winform 自动更新程序,供大家参考,具体内容如下 第一步:检查更新 检查更新其实无非就是去比较更新包的版本和本地软件版本,如果高则更新.低则不更新.怎么获取版本号方法很多,本案例是获取软件的配置文件. private bool CheckUpdate() { bool result = false; try { string Cfg = TxtRead(exePath "\\Config.txt"); ConfigLocal = JsonConvert.

  • 用c# 自动更新程序

    作者:冰封一夏 出处:http://www.cnblogs.com/bfyx/ HZHControls官网:http://www.hzhcontrols.com 首先看获取和更新的接口 更新程序Program.cs using System; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Linq; using System.Threading.Tasks; us

  • c# 如何实现自动更新程序

    主要功能介绍 实现文件的自动更新.主要功能: 支持整包完全更新,即客户端只需输入一个服务器地址,即可下载所有文件. 支持增量更新,即只更新指定的某几个文件. 支持自动更新程序的更新 更新界面如图: 客户端 main方法入口 /// <summary> /// 应用程序的主入口点. /// </summary> [STAThread] static void Main() { //在主程序中 更新替换自动升级程序 //ReplaceAutoUpgrade(); bool isEnte

  • C# WinForm实现自动更新程序之客户端的示例代码

    目录 前言 开发环境 开发工具 实现代码 实现效果 前言 第二步理论上我们该写客户端了,但是,在此之前,需要先介绍下一些必要的方法以及操作. 写代码还是要尽量的保证通用性,以便以后需要的时候可以拿来稍微改改甚至直接使用.所以在这里我们将自动更新的程序抽象出来,即对于客户端来说,它只包含三个文件(AutoUpdate.dll.AutoUpdate.exe.UpdateList.xml,如果是.NET Framework的话,其实是没有AutoUpdate.dll文件的,就一个exe就足够了.这也是

  • 详解C# WinForm如何实现自动更新程序

    目录 前言 开发环境 开发工具 实现代码 实现效果 前言 在C/S这种模式中,自动更新程序就显得尤为重要,它不像B/S模式,直接发布到服务器上,浏览器点个刷新就可以了.由于涉及到客户端文件,所以必然需要把相应的文件下载下来.这个其实比较常见,我们常用的微信.QQ等,也都是这个操作. 自动更新程序也分为客户端和服务端两部分,客户端就是用来下载的一个小程序,服务端就是供客户端调用下载接口等操作. 这里第一步先将服务端代码写出来,逻辑比较简单,使用xml文件分别存储各个文件的名称以及版本号(每次需要更

  • Android App实现应用内部自动更新的最基本方法示例

    这只是初步的实现,并没有加入自动编译等功能.需要手动更改更新的xml文件和最新的apk.    共涉及到四个文件! 一.客户端 AndroidUpdateTestActivity:程序首页 main.xml:首页布局 Update:更新类 softupdate_progress:更新等待界面 Updage package majier.test; import java.io.File; import java.io.FileOutputStream; import java.io.IOExce

  • C#基于FTP协议的简易软件自动升级程序

    最近在重写了一个老的产品条码扫描程序,客户端数越有30个,因为经常有更新,C/S维护非常不方便,所以做一个自动更新程序特别有必要. 在网上随便找了找自动更新的方案,大多使用VS的发布/更新功能,不太喜欢此方案,觉得太麻烦,然后自己初步琢磨了一下如下方案. 现在比较喜欢的编程方式,先画图. 软件更新流程 安装包的制作 为了简单,采用了自解压压缩包的方式制作更新包,将整个新程序包打包为一个自解压压缩包. 以下是我的自解压包的参数设置,怎样制作自解压包网上有很多教程,可以自己去搜索. 常规-解压路径:

  • Android程序自动更新功能模块的实现方法【附完整demo源码下载】

    本文实例讲述了Android程序自动更新功能模块的实现方法.分享给大家供大家参考,具体如下: 在程序启动的时候检测服务器上有没有对应版本更新,如果有更新,提示用户是否更新. 在程序启动的时候首先调用更新模块检测服务器上存放的版本号跟当前程序的版本号如果大于当前版本号,弹出更新对话框,如果用户选择更新,则显示当前更新状态,然后替换当前程序. 程序调用版本更新检测: private UpdateManager updateMan; private ProgressDialog updateProgr

  • 关于微信小程序爬虫token自动更新问题

    目录 一.微信模拟点击 二.配置fiddler获取请求头的信息写到本地文件 三.主爬虫业务代码 现在很多的app都很喜欢在微信或者支付宝的小程序内做开发,毕竟比较方便.安全.有流量.不需要再次下载app,好多人会因为加入你让他下载app他会扭头就走不用你的app,毕竟做类似产品的不是你一家. 之前做过很多微信小程序的爬虫任务,今天做下记录,防止很久不用后就会忘记,微信小程序分为两大类: 1.是不需要登录的(这种的话不做分析,毕竟没什么反爬) 2.需要登录的 2.1 登录一次之后token永久有效

随机推荐