logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

金蝶K3 WISE版本过服务期后打补丁方法

 小雪初晴i 2021-02-04

读了这位博主的内容有所启发

https://blog.csdn.net/hzfw2008/article/details/106991629

金蝶补丁一般安装过后，都会进行解包，分两部分，第一部分为完整解包，第二部分为使用备份包

先讲第二部分，使用的备份包，也就这里有用，不是全系列产品完整的包补丁内容。

 比如，k3 wise 15.0 PT124991包，只需要更新 一个exe和VER内容，其他不需要的东东，不在此处体现，在完整包里面体现。

 Kingdee_SP_Install_Log_PT124991.log，为安装日志，从而可以用来参考复制到哪里。

  1. ********* Start installation: 6-17-2020 09:31:54 *********


  4.  call K3DCOMManageStop.exe
  5. File : C:\Program Files (x86)\Kingdee\K3ERP\K3ClassDEFINENewUSER.exe
  6. FileName : K3ClassDEFINENewUSER.exe
  7. Path : C:\Program Files (x86)\Kingdee\K3ERP\
  8. Backup File :  C:\Program Files (x86)\Kingdee\K3ERP\K3ClassDEFINENewUSER.exe
  9. Replace File:  C:\Program Files (x86)\Kingdee\K3ERP\K3ClassDEFINENewUSER.exe

  11. File : C:\Program Files (x86)\Kingdee\K3ERP\KDSYSTEM\K3MFYGLMakeVoucher.VBR
  12. FileName : K3MFYGLMakeVoucher.VBR
  13. Path : C:\Program Files (x86)\Kingdee\K3ERP\KDSYSTEM\
  14. Backup File :  C:\Program Files (x86)\Kingdee\K3ERP\KDSYSTEM\K3MFYGLMakeVoucher.VBR
  15. Replace File:  C:\Program Files (x86)\Kingdee\K3ERP\KDSYSTEM\K3MFYGLMakeVoucher.VBR


  18. ------- Finish Copying File(s): 6-17-2020 09:32:34 -------

  20.  call BatAndExe.bat

  22.  call K3DCOMManageStart.exe

  24. ********** End installation: 6-17-2020 09:32:37 **********

现在讲第一部分

还以PT124991补丁包举例子，这里面是次补丁涉及到的所有，不仅局限与客户端、服务端，还有其他等等，也不用仔细研究这个，总之是完整解包的内容。

 KDPatchs这个文件夹其实木有卵用。

因为新的金蝶补丁全部加壳，在服务期内的通过验证后，可以打补丁。超过服务期的，正常是打不了的，可以通过如下方法变通处理下：

 1、找一台已经装好补丁的客户端(如果找不到，那就用金蝶服务器也行)。将客户端下面如下2个目录的文件夹打包压缩备用。如果提示被占用，请先使用任务管理器结束K3或者KD打头的进程；

2、在新的系统上按照标准方法安装金蝶K3客户端。跑一遍中间层组件注册；

3、将上面打包压缩的2个文件夹覆盖掉新系统的同名文件夹；

4、打开新系统的该目录，使用管理员权限运行如下2个批处理文件，重新进行组件注册；

这两个bat，一个是注册中间件的，一个是注册产品的。总之重新注册一下就好。

有人该问了，控制面板卸载软件里面有木有补丁包信息，已经注册表里面有木有，这个肯定木有了，相当于绿色了。这就涉及到第5条的内容，第5条继续说。

 

 

 

 5、运行桌面K3图标即可正常使用金蝶客户端。

这里就遇见坑了。什么坑呢，只要打开金蝶就自己下载补丁包进行安装，这不扯淡了嘛。本来拷贝过来的文件里面就有补丁。其实呢是因为一个自动打补丁的东东，只要你打开金蝶就开始检测注册表里面是不是已经安装过这个补丁了，没有就下载进行安装。

这么蛋疼的事情，就不备份已经安装过补丁电脑的相关注册表了，直接干掉这个自动补丁安装程序就好了。

Kingdee.K3.BaseNet.UpdatePatchApp.exe

这个程序在金蝶安装根目录里面，将其删掉，或者改名就好。

Program

  1. using System;
  2. using System.Windows;
  3. using Kingdee.K3.BaseNet.AutoUpdatePatchCommon;

  5. namespace Kingdee.K3.BaseNet.UpdatePatchApp
  6. {
  7.     // Token: 0x02000003 RID: 3
  8.     public class Program
  9.     {
  10.         // Token: 0x06000005 RID: 5 RVA: 0x000021D0 File Offset: 0x000003D0
  11.         [STAThread]
  12.         private static void Main(string[] args)
  13.         {
  14.             Log.WriteLog("进入客户端补丁升级工具Kingdee.K3.BaseNet.UpdatePatchApp.exe");
  15.             if (args == null || args.Length != 1)
  16.             {
  17.                 Log.WriteLog("args == null || args.Length != 1,退出客户端补丁升级工具!");
  18.                 return;
  19.             }
  20.             Log.WriteLog("外部传入客户端补丁升级工具参数:" + args[0]);
  21.             new Application().Run(new ProgressWindow(args[0]));
  22.         }
  23.     }
  24. }

Common

  1. using System;
  2. using System.Diagnostics;
  3. using System.Reflection;
  4. using Kingdee.K3.BaseNet.AutoUpdatePatchCommon;

  6. namespace Kingdee.K3.BaseNet.UpdatePatchApp
  7. {
  8.     // Token: 0x02000002 RID: 2
  9.     public class Common
  10.     {
  11.         // Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
  12.         public static string LoadKDString(string strText)
  13.         {
  14.             string result;
  15.             try
  16.             {
  17.                 Type typeFromProgID = Type.GetTypeFromProgID("K3BaseDataAccess.CMultiLanguage");
  18.                 object target = Activator.CreateInstance(typeFromProgID);
  19.                 object[] args = new object[]
  20.                 {
  21.                     strText,
  22.                     "K3Base"
  23.                 };
  24.                 result = (string)typeFromProgID.InvokeMember("LoadKDString", BindingFlags.Public | BindingFlags.InvokeMethod, null, target, args);
  25.             }
  26.             catch
  27.             {
  28.                 Log.WriteLog("Kingdee.K3.BaseNet.UpdatePathApp.LoadKDString(),Error strText=" + strText);
  29.                 result = strText;
  30.             }
  31.             return result;
  32.         }

  34.         // Token: 0x06000002 RID: 2 RVA: 0x000020CC File Offset: 0x000002CC
  35.         public static bool IsOpenAntivirus()
  36.         {
  37.             bool result = false;
  38.             try
  39.             {
  40.                 Process[] processesByName = Process.GetProcessesByName("360sd");
  41.                 if (processesByName.Length == 0)
  42.                 {
  43.                     processesByName = Process.GetProcessesByName("360Tray");
  44.                     if (processesByName.Length > 0)
  45.                     {
  46.                         Log.WriteLog("检测到客户端安装了360安全卫士");
  47.                         result = true;
  48.                     }
  49.                 }
  50.                 else
  51.                 {
  52.                     Log.WriteLog("检测到客户端安装了360杀毒软件");
  53.                     result = true;
  54.                 }
  55.             }
  56.             catch (Exception ex)
  57.             {
  58.                 Log.WriteLog("判断是否开启杀毒软件报错IsOpenAntivirus:" + ex.ToString());
  59.             }
  60.             return result;
  61.         }

  63.         // Token: 0x06000003 RID: 3 RVA: 0x00002144 File Offset: 0x00000344
  64.         public static void ClosedK3Proc(string strProcName)
  65.         {
  66.             try
  67.             {
  68.                 Log.WriteLog(string.Format("检测K3进程{0}", strProcName));
  69.                 Process[] processesByName = Process.GetProcessesByName(strProcName);
  70.                 int num = processesByName.Length;
  71.                 Log.WriteLog(string.Format("检测K3进程{0}有{1}个,下一步这些关闭进程", strProcName, num));
  72.                 if (num > 0)
  73.                 {
  74.                     for (int i = 0; i < num; i++)
  75.                     {
  76.                         processesByName[i].Kill();
  77.                     }
  78.                 }
  79.             }
  80.             catch (Exception ex)
  81.             {
  82.                 Log.WriteLog(string.Format("强制关闭{0}主控台报错:{1}", strProcName, ex.ToString()));
  83.             }
  84.         }
  85.     }
  86. }

ProgressWindow

  1. using System;
  2. using System.CodeDom.Compiler;
  3. using System.Collections.Generic;
  4. using System.ComponentModel;
  5. using System.Diagnostics;
  6. using System.IO;
  7. using System.Linq;
  8. using System.Threading;
  9. using System.Windows;
  10. using System.Windows.Controls;
  11. using System.Windows.Markup;
  12. using System.Windows.Media;
  13. using System.Windows.Media.Animation;
  14. using System.Windows.Threading;
  15. using Kingdee.K3.BaseNet.AutoUpdatePatchClient;
  16. using Kingdee.K3.BaseNet.AutoUpdatePatchCommon;

  18. namespace Kingdee.K3.BaseNet.UpdatePatchApp
  19. {
  20.     // Token: 0x02000004 RID: 4
  21.     public class ProgressWindow : Window, IComponentConnector
  22.     {
  23.         // Token: 0x17000001 RID: 1
  24.         // (get) Token: 0x06000007 RID: 7 RVA: 0x00002228 File Offset: 0x00000428
  25.         // (set) Token: 0x06000008 RID: 8 RVA: 0x0000223A File Offset: 0x0000043A
  26.         public string Message
  27.         {
  28.             get
  29.             {
  30.                 return (string)base.GetValue(ProgressWindow.MessageProperty);
  31.             }
  32.             set
  33.             {
  34.                 base.SetValue(ProgressWindow.MessageProperty, value);
  35.             }
  36.         }

  38.         // Token: 0x17000002 RID: 2
  39.         // (get) Token: 0x06000009 RID: 9 RVA: 0x00002248 File Offset: 0x00000448
  40.         // (set) Token: 0x0600000A RID: 10 RVA: 0x0000225A File Offset: 0x0000045A
  41.         public int ProgressValue
  42.         {
  43.             get
  44.             {
  45.                 return (int)base.GetValue(ProgressWindow.ProgressValueProperty);
  46.             }
  47.             set
  48.             {
  49.                 base.SetValue(ProgressWindow.ProgressValueProperty, value);
  50.             }
  51.         }

  53.         // Token: 0x17000003 RID: 3
  54.         // (get) Token: 0x0600000B RID: 11 RVA: 0x0000226D File Offset: 0x0000046D
  55.         // (set) Token: 0x0600000C RID: 12 RVA: 0x0000227F File Offset: 0x0000047F
  56.         public int ProgressMaximum
  57.         {
  58.             get
  59.             {
  60.                 return (int)base.GetValue(ProgressWindow.ProgressMaximumProperty);
  61.             }
  62.             set
  63.             {
  64.                 base.SetValue(ProgressWindow.ProgressMaximumProperty, value);
  65.             }
  66.         }

  68.         // Token: 0x0600000D RID: 13 RVA: 0x00002294 File Offset: 0x00000494
  69.         public ProgressWindow(string k3StartupProgromName)
  70.         {
  71.             try
  72.             {
  73.                 this.m_lstNeedInstallPatch = this.GetNeesInstallPatchs();
  74.                 if (this.m_lstNeedInstallPatch.Count == 0)
  75.                 {
  76.                     Log.WriteLog(string.Format("本客户端没有补丁需要安装,直接退出补丁更新工具", new object[0]));
  77.                     Application.Current.Shutdown();
  78.                 }
  79.                 else
  80.                 {
  81.                     string text = "";
  82.                     try
  83.                     {
  84.                         text = PatchVerify.GetRegistryKeyValue("", "IsAuto");
  85.                     }
  86.                     catch (Exception)
  87.                     {
  88.                     }
  89.                     Log.WriteLog("读取注册表 IsAuto=" + text + "," + ((text == "1") ? "当前机器正在安装补丁，请稍后再尝试！。" : "空值可进行补丁安装"));
  90.                     if (text == "1")
  91.                     {
  92.                         Process[] processesByName = Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName);
  93.                         if (processesByName.Length > 1)
  94.                         {
  95.                             MessageBox.Show(Common.LoadKDString("客户端正在更新补丁，请稍后再尝试！"), Common.LoadKDString("金蝶提示"), MessageBoxButton.OK, MessageBoxImage.Asterisk);
  96.                             Application.Current.Shutdown();
  97.                             return;
  98.                         }
  99.                     }
  100.                     this.InitializeComponent();
  101.                     base.DataContext = this;
  102.                     this._k3StartupProgromName = k3StartupProgromName;
  103.                 }
  104.             }
  105.             catch (Exception ex)
  106.             {
  107.                 Log.WriteLog(string.Format("补丁更新工具报错，直接退出:{0}", ex.ToString()));
  108.             }
  109.         }

  111.         // Token: 0x0600000E RID: 14 RVA: 0x000024AC File Offset: 0x000006AC
  112.         private void UpdatePatchs()
  113.         {
  114.             bool flag = false;
  115.             try
  116.             {
  117.                 PatchVerify.SetIsAutoRegedit("1");
  118.             }
  119.             catch (Exception ex)
  120.             {
  121.                 Log.WriteLog("读取注册表" + ex.ToString());
  122.             }
  123.             Action<string> method = delegate(string message)
  124.             {
  125.                 this.Message = message;
  126.             };
  127.             Action<int> method2 = delegate(int progressValue)
  128.             {
  129.                 this.ProgressValue = progressValue;
  130.             };
  131.             Action<int> method3 = delegate(int progressMaximum)
  132.             {
  133.                 this.ProgressMaximum = progressMaximum;
  134.             };
  135.             Action method4 = delegate()
  136.             {
  137.                 Storyboard storyboard = base.Resources["ClosedStoryboard"] as Storyboard;
  138.                 storyboard.Completed += delegate(object A_1, EventArgs A_2)
  139.                 {
  140.                     base.Close();
  141.                 };
  142.                 storyboard.Begin();
  143.             };
  144.             try
  145.             {
  146.                 Thread.Sleep(3000);
  147.                 ProcessStartInfo processStartInfo = null;
  148.                 Process process = null;
  149.                 int num = 0;
  150.                 bool flag2 = true;
  151.                 Func<bool> func = delegate()
  152.                 {
  153.                     process = new Process
  154.                     {
  155.                         StartInfo = processStartInfo
  156.                     };
  157.                     process.Start();
  158.                     bool result = process.WaitForExit(1800000);
  159.                     process.Close();
  160.                     return result;
  161.                 };
  162.                 List<string> lstNeedInstallPatch = this.m_lstNeedInstallPatch;
  163.                 base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method3, lstNeedInstallPatch.Count * 4);
  164.                 int num2 = 0;
  165.                 int count = lstNeedInstallPatch.Count;
  166.                 foreach (string text in lstNeedInstallPatch)
  167.                 {
  168.                     base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method2, num2 * 4);
  169.                     string[] array = text.Split(new char[]
  170.                     {
  171.                         '|'
  172.                     });
  173.                     bool flag3 = array[0] == "0";
  174.                     string patchNo = array[1];
  175.                     string arg = string.Concat(new object[]
  176.                     {
  177.                         Common.LoadKDString("正在安装第"),
  178.                         num2 + 1,
  179.                         Common.LoadKDString("个补丁"),
  180.                         patchNo,
  181.                         Common.LoadKDString(",共"),
  182.                         count,
  183.                         Common.LoadKDString("个,请稍候...")
  184.                     });
  185.                     PatchTransfer patchTransfer = new PatchTransfer();
  186.                     string text2 = Path.Combine(SocketTransferData.PatchDiretory, string.Format("{0}.rar", patchNo));
  187.                     base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method2, num2 * 4 + 1);
  188.                     base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, arg);
  189.                     patchTransfer.DownloadPatchToServer(string.Format("{0}.rar", patchNo), ref num);
  190.                     if (flag2)
  191.                     {
  192.                         string text3 = Path.Combine(Path.Combine(SocketTransferData.PatchDiretory, patchNo), string.Format("{0}.exe", patchNo));
  193.                         if (flag3 && PatchVerify.IsPatchInstallLocal(patchNo))
  194.                         {
  195.                             base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, patchNo + Common.LoadKDString("已安装，不进行重复安装"));
  196.                             Log.WriteLog(string.Format("{0}已安装，不进行重复安装", patchNo));
  197.                             continue;
  198.                         }
  199.                         string text4 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "WinRAR.exe");
  200.                         Path.GetDirectoryName(text4);
  201.                         FileInfo fileInfo = new FileInfo(text2);
  202.                         string arguments = string.Format("x \"{0}\" \"{1}\" -y -ibck -inul", text2, fileInfo.DirectoryName);
  203.                         if (File.Exists(text2))
  204.                         {
  205.                             base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method2, num2 * 4 + 2);
  206.                             processStartInfo = new ProcessStartInfo
  207.                             {
  208.                                 FileName = text4,
  209.                                 Arguments = arguments,
  210.                                 WindowStyle = ProcessWindowStyle.Hidden,
  211.                                 UseShellExecute = false,
  212.                                 CreateNoWindow = true,
  213.                                 RedirectStandardError = true,
  214.                                 RedirectStandardInput = true,
  215.                                 RedirectStandardOutput = true,
  216.                                 Verb = "runas"
  217.                             };
  218.                             base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, Common.LoadKDString("正在解压") + patchNo);
  219.                             if (func())
  220.                             {
  221.                                 base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, patchNo + Common.LoadKDString("已解压"));
  222.                                 Log.WriteLog(string.Format("{0}已解压", patchNo));
  223.                                 PatchVerify.DeleteRegedit(patchNo);
  224.                                 if (File.Exists(text3))
  225.                                 {
  226.                                     processStartInfo = new ProcessStartInfo
  227.                                     {
  228.                                         FileName = text3,
  229.                                         WindowStyle = ProcessWindowStyle.Hidden,
  230.                                         UseShellExecute = false,
  231.                                         CreateNoWindow = true,
  232.                                         Arguments = " -slient",
  233.                                         Verb = "runas"
  234.                                     };
  235.                                     base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, arg);
  236.                                     base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method2, num2 * 4 + 3);
  237.                                     if (func())
  238.                                     {
  239.                                         base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, Common.LoadKDString("已安装") + patchNo);
  240.                                         Log.WriteLog(string.Format("{0}已安装", patchNo));
  241.                                         if (!flag3)
  242.                                         {
  243.                                             if ((from dr1 in PatchInstall.dt_InstalledPatch
  244.                                             where dr1.PatchNo == patchNo
  245.                                             select 1).Count<int>() == 0)
  246.                                             {
  247.                                                 DataSet1.DT_InstalledPatchRow dt_InstalledPatchRow = PatchInstall.dt_InstalledPatch.NewDT_InstalledPatchRow();
  248.                                                 dt_InstalledPatchRow.PatchNo = patchNo;
  249.                                                 PatchInstall.dt_InstalledPatch.AddDT_InstalledPatchRow(dt_InstalledPatchRow);
  250.                                                 PatchInstall.dt_InstalledPatch.WriteXml(PatchInstall.installedPatchFilePath);
  251.                                             }
  252.                                             Log.WriteLog(string.Format("{0}已更新补丁状态", patchNo));
  253.                                         }
  254.                                     }
  255.                                     else
  256.                                     {
  257.                                         base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, patchNo + Common.LoadKDString("安装失败"));
  258.                                         Log.WriteLog(string.Format("{0}安装失败", patchNo));
  259.                                         File.Delete(text3);
  260.                                         if (flag3)
  261.                                         {
  262.                                             flag2 = false;
  263.                                             continue;
  264.                                         }
  265.                                         continue;
  266.                                     }
  267.                                 }
  268.                                 else
  269.                                 {
  270.                                     base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, Common.LoadKDString("无法找到补丁文件") + text3);
  271.                                     Log.WriteLog(string.Format("无法找到补丁文件 {0}", text3));
  272.                                 }
  273.                             }
  274.                             else
  275.                             {
  276.                                 base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, patchNo + Common.LoadKDString("解压失败"));
  277.                                 Log.WriteLog(string.Format("{0}解压失败", patchNo));
  278.                                 if (flag3)
  279.                                 {
  280.                                     flag2 = false;
  281.                                     continue;
  282.                                 }
  283.                                 continue;
  284.                             }
  285.                         }
  286.                         else
  287.                         {
  288.                             base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, Common.LoadKDString("无法找到补丁压缩包文件") + text2);
  289.                             Log.WriteLog(string.Format("无法找到补丁压缩包文件 {0}", text2));
  290.                         }
  291.                     }
  292.                     else
  293.                     {
  294.                         base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, Common.LoadKDString("由于前置补丁安装异常，未安装") + patchNo);
  295.                         Log.WriteLog(string.Format("由于前置补丁安装异常，{0}未安装", patchNo));
  296.                         if (!flag3)
  297.                         {
  298.                             flag2 = true;
  299.                         }
  300.                     }
  301.                     base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method2, num2 * 4 + 4);
  302.                     num2++;
  303.                 }
  304.                 base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method, Common.LoadKDString("更新完成，启动K3WISE控制台"));
  305.                 flag = true;
  306.             }
  307.             catch (Exception ex2)
  308.             {
  309.                 flag = false;
  310.                 Log.WriteLog(ex2.ToString());
  311.             }
  312.             finally
  313.             {
  314.                 try
  315.                 {
  316.                     PatchVerify.SetIsAutoRegedit("");
  317.                 }
  318.                 catch (Exception ex3)
  319.                 {
  320.                     Log.WriteLog("读取注册表" + ex3.ToString());
  321.                 }
  322.                 Thread.Sleep(1000);
  323.                 base.Dispatcher.Invoke(DispatcherPriority.SystemIdle, method4);
  324.                 if (!flag)
  325.                 {
  326.                     MessageBoxResult messageBoxResult = MessageBox.Show(Common.LoadKDString("补丁安装过程中出现异常，可能导致K3使用过程中出现异常，请联系管理员。\r\n是否要继续打开K3？"), Common.LoadKDString("金蝶提示"), MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
  327.                     if (messageBoxResult == MessageBoxResult.Yes)
  328.                     {
  329.                         flag = true;
  330.                     }
  331.                 }
  332.                 if (flag)
  333.                 {
  334.                     string text5 = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, this._k3StartupProgromName + ".exe");
  335.                     Log.WriteLog("补丁更新完成，启动主控台，启动路径:" + text5);
  336.                     if (!File.Exists(text5))
  337.                     {
  338.                         MessageBox.Show(text5 + Common.LoadKDString("路径不正确！"));
  339.                     }
  340.                     ProcessStartInfo startInfo = new ProcessStartInfo
  341.                     {
  342.                         FileName = text5,
  343.                         WindowStyle = ProcessWindowStyle.Hidden,
  344.                         UseShellExecute = false,
  345.                         Arguments = "updated",
  346.                         Verb = "runas"
  347.                     };
  348.                     Process process2 = new Process
  349.                     {
  350.                         StartInfo = startInfo
  351.                     };
  352.                     process2.Start();
  353.                 }
  354.             }
  355.         }

  357.         // Token: 0x0600000F RID: 15 RVA: 0x00002D30 File Offset: 0x00000F30
  358.         private List<string> GetNeesInstallPatchs()
  359.         {
  360.             List<string> list = new List<string>();
  361.             try
  362.             {
  363.                 bool flag = PatchInstall.IsNeedUpdatePatch();
  364.                 if (flag)
  365.                 {
  366.                     list = PatchInstall.m_NeedInstallPatchList;
  367.                     if (list == null)
  368.                     {
  369.                         Log.WriteLog(string.Format("方法GetNeesInstallPatchs判断客户端是否有补丁需要安装得出值为null", new object[0]));
  370.                         return list;
  371.                     }
  372.                     int count = list.Count;
  373.                     Log.WriteLog(string.Format("方法GetNeesInstallPatchs判断客户端是否有补丁需要安装检测到有{0}个补丁需要安装", count));
  374.                     for (int i = count - 1; i >= 0; i--)
  375.                     {
  376.                         string text = list[i];
  377.                         string[] array = text.Split(new char[]
  378.                         {
  379.                             '|'
  380.                         });
  381.                         string text2 = array[1];
  382.                         bool flag2 = PatchVerify.IsPatchInstallLocal(text2);
  383.                         if (flag2)
  384.                         {
  385.                             list.RemoveAt(i);
  386.                         }
  387.                     }
  388.                 }
  389.             }
  390.             catch (Exception ex)
  391.             {
  392.                 Log.WriteLog(string.Format("方法GetNeesInstallPatchs判断客户端是否有补丁需要安装报错:{0}", ex.ToString()));
  393.             }
  394.             return list;
  395.         }

  397.         // Token: 0x06000010 RID: 16 RVA: 0x00002E28 File Offset: 0x00001028
  398.         private void Window_Loaded(object sender, RoutedEventArgs e)
  399.         {
  400.             try
  401.             {
  402.                 int count = this.m_lstNeedInstallPatch.Count;
  403.                 if (count > 0)
  404.                 {
  405.                     Common.ClosedK3Proc(this._k3StartupProgromName);
  406.                     (base.Resources["OpenStoryboard"] as Storyboard).Begin();
  407.                     this.Main.OpacityMask = (base.Resources["ClosedBrush"] as LinearGradientBrush);
  408.                     Log.WriteLog(string.Format("客户端补丁更新工具最终结果检测到有{0}个补丁需要在本客户端安装,马上进入安装阶段", count));
  409.                     if (Common.IsOpenAntivirus())
  410.                     {
  411.                         MessageBox.Show(Common.LoadKDString("安装补丁前请关闭杀毒软件！"), Common.LoadKDString("金蝶提示"), MessageBoxButton.OK, MessageBoxImage.Exclamation);
  412.                     }
  413.                     new Thread(new ThreadStart(this.UpdatePatchs)).Start();
  414.                 }
  415.                 else
  416.                 {
  417.                     Log.WriteLog(string.Format("本客户端没有补丁需要安装", new object[0]));
  418.                 }
  419.             }
  420.             catch (Exception ex)
  421.             {
  422.                 Log.WriteLog(string.Format("客户端补丁更新工具Kingdee.K3.BaseNet.UpdatePatchApp.exe报错:{0}", ex.ToString()));
  423.             }
  424.         }

  426.         // Token: 0x06000011 RID: 17 RVA: 0x00002F24 File Offset: 0x00001124
  427.         [DebuggerNonUserCode]
  428.         [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
  429.         public void InitializeComponent()
  430.         {
  431.             if (this._contentLoaded)
  432.             {
  433.                 return;
  434.             }
  435.             this._contentLoaded = true;
  436.             Uri resourceLocator = new Uri("/Kingdee.K3.BaseNet.UpdatePatchApp;component/progresswindow.xaml", UriKind.Relative);
  437.             Application.LoadComponent(this, resourceLocator);
  438.         }

  440.         // Token: 0x06000012 RID: 18 RVA: 0x00002F54 File Offset: 0x00001154
  441.         [GeneratedCode("PresentationBuildTasks", "4.0.0.0")]
  442.         [EditorBrowsable(EditorBrowsableState.Never)]
  443.         [DebuggerNonUserCode]
  444.         void IComponentConnector.Connect(int connectionId, object target)
  445.         {
  446.             switch (connectionId)
  447.             {
  448.             case 1:
  449.                 ((ProgressWindow)target).Loaded += this.Window_Loaded;
  450.                 return;
  451.             case 2:
  452.                 this.Screen = (Grid)target;
  453.                 return;
  454.             case 3:
  455.                 this.Main = (Border)target;
  456.                 return;
  457.             default:
  458.                 this._contentLoaded = true;
  459.                 return;
  460.             }
  461.         }

  463.         // Token: 0x04000001 RID: 1
  464.         private string _k3StartupProgromName;

  466.         // Token: 0x04000002 RID: 2
  467.         public static readonly DependencyProperty MessageProperty = DependencyProperty.Register("Message", typeof(string), typeof(ProgressWindow), new PropertyMetadata(Common.LoadKDString("开始更新")));

  469.         // Token: 0x04000003 RID: 3
  470.         public static readonly DependencyProperty ProgressValueProperty = DependencyProperty.Register("ProgressValue", typeof(int), typeof(ProgressWindow), new PropertyMetadata(0));

  472.         // Token: 0x04000004 RID: 4
  473.         public static readonly DependencyProperty ProgressMaximumProperty = DependencyProperty.Register("ProgressMaximum", typeof(int), typeof(ProgressWindow), new PropertyMetadata(100));

  475.         // Token: 0x04000005 RID: 5
  476.         private List<string> m_lstNeedInstallPatch = new List<string>();

  478.         // Token: 0x04000006 RID: 6
  479.         internal Grid Screen;

  481.         // Token: 0x04000007 RID: 7
  482.         internal Border Main;

  484.         // Token: 0x04000008 RID: 8
  485.         private bool _contentLoaded;
  486.     }
  487. }

至于有木有真正的打上补丁，自己去实验吧。总之我是验证过了，包括补丁包里面的内容md5值都已经比对过，和安装过补丁的电脑文件md5值一样。

有点拗口，这里可以忽略。

 使用的系统也忽略哈，Linux是我的主战场，一条md5sum进行计算，多么方便。

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 小雪初晴i > 《K3》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多