zhao：上传框架

Common/AESHelper.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Common
+{
+    /// <summary>
+    /// AES加密
+    /// 创建人：赵耀
+    /// 创建时间：2020年9月7日
+    /// </summary>
+    public class AESHelper
+    {
+        public static string QrcodeLoginKey = "zyyxhlywkdatakey";
+
+        /// <summary>
+        /// AES 加密
+        /// </summary>
+        /// <param name="content">Need encrypted string</param>
+        /// <returns>Encrypted 16 hex string</returns>
+        public static string AESEncrypt(string Data)
+        {
+            string key = QrcodeLoginKey.PadRight(16, '0');
+            // 256-AES key      
+            byte[] keyArray = UTF8Encoding.ASCII.GetBytes(key);
+            byte[] toEncryptArray = UTF8Encoding.ASCII.GetBytes(Data);
+
+            RijndaelManaged rDel = new RijndaelManaged
+            {
+                Key = keyArray,
+                Mode = CipherMode.ECB,
+                Padding = PaddingMode.PKCS7
+            };
+
+            ICryptoTransform cTransform = rDel.CreateEncryptor();
+            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0,
+                    toEncryptArray.Length);
+
+            return BytesToHexString(resultArray);
+        }
+
+        /// <summary>
+        /// AES 解密
+        /// </summary>
+        /// <param name="hexString">Encrypted 16 hex string</param>
+        /// <returns>Decrypted string</returns>
+        public static string AESDecrypt(string hexString)
+        {
+            string key = QrcodeLoginKey.PadRight(16, '0');
+            // 256-AES key      
+            byte[] keyArray = UTF8Encoding.ASCII.GetBytes(key);
+            byte[] toEncryptArray = HexStringToBytes(hexString);
+
+            RijndaelManaged rDel = new RijndaelManaged
+            {
+                Key = keyArray,
+                Mode = CipherMode.ECB,
+                Padding = PaddingMode.PKCS7
+            };
+
+            ICryptoTransform cTransform = rDel.CreateDecryptor();
+            byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0,
+                    toEncryptArray.Length);
+
+            return UTF8Encoding.ASCII.GetString(resultArray);
+        }
+
+        /// <summary>
+        /// Byte array to convert 16 hex string
+        /// </summary>
+        /// <param name="bytes">byte array</param>
+        /// <returns>16 hex string</returns>
+        public static string BytesToHexString(byte[] bytes)
+        {
+            StringBuilder returnStr = new StringBuilder();
+            if (bytes != null || bytes.Length == 0)
+            {
+                for (int i = 0; i < bytes.Length; i++)
+                {
+                    returnStr.Append(bytes[i].ToString("X2"));
+                }
+            }
+            return returnStr.ToString();
+        }
+
+        /// <summary>
+        /// 16 hex string converted to byte array
+        /// </summary>
+        /// <param name="hexString">16 hex string</param>
+        /// <returns>byte array</returns>
+        public static byte[] HexStringToBytes(string hexString)
+        {
+            if (hexString == null || hexString.Equals(""))
+            {
+                return null;
+            }
+            int length = hexString.Length / 2;
+            if (hexString.Length % 2 != 0)
+            {
+                return null;
+            }
+            byte[] d = new byte[length];
+            for (int i = 0; i < length; i++)
+            {
+                d[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
+            }
+            return d;
+        }
+    }
+}

Common/Common.csproj

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{808A7075-5AF5-46B3-8EF6-514C0B5FA8D7}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Common</RootNamespace>
+    <AssemblyName>Common</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="ICSharpCode.SharpZipLib">
+      <HintPath>dlls\ICSharpCode.SharpZipLib.dll</HintPath>
+    </Reference>
+    <Reference Include="log4net">
+      <HintPath>dlls\log4net.dll</HintPath>
+    </Reference>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>dlls\Newtonsoft.Json.dll</HintPath>
+    </Reference>
+    <Reference Include="O2S.Components.PDFRender4NET">
+      <HintPath>..\dl\O2S.Components.PDFRender4NET.dll</HintPath>
+    </Reference>
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+    <Reference Include="System" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Data.SQLite">
+      <HintPath>dlls\System.Data.SQLite.dll</HintPath>
+    </Reference>
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Web" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+    <Reference Include="WindowsBase" />
+    <Reference Include="WindowsFormsIntegration" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AESHelper.cs" />
+    <Compile Include="Model\DownloadInfoModel.cs" />
+    <Compile Include="system\BackgroundWorkerHelper.cs" />
+    <Compile Include="system\DataProvider.cs" />
+    <Compile Include="system\KeyboardHookCommon.cs" />
+    <Compile Include="system\MouseEventCommon.cs" />
+    <Compile Include="system\NumUtil.cs" />
+    <Compile Include="system\PdfTrunImage.cs" />
+    <Compile Include="system\BlackboardNew.cs" />
+    <Compile Include="system\CLeopardZip.cs" />
+    <Compile Include="system\DataConvertCommon.cs" />
+    <Compile Include="system\DownloadManager.cs" />
+    <Compile Include="system\DownloadService.cs" />
+    <Compile Include="system\FileToolsCommon.cs" />
+    <Compile Include="system\FreeMemoryHelper.cs" />
+    <Compile Include="system\HttpHelper.cs" />
+    <Compile Include="system\ImageHelper.cs" />
+    <Compile Include="system\JsonHelper.cs" />
+    <Compile Include="system\LogHelper.cs" />
+    <Compile Include="system\PrimaryScreen.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="system\RegistryHelper.cs" />
+    <Compile Include="system\SplashScreen.cs" />
+    <Compile Include="system\XmlUtilHelper.cs" />
+    <Compile Include="system\ZJClippingBorder.cs" />
+    <Compile Include="ZB\ClippingBorder.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="dlls\" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="log4net.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

Common/Model/DownloadInfoModel.cs

@@ -0,0 +1,174 @@
+using System.Collections.Generic;
+
+namespace Common.Model
+{
+    /// <summary>
+    /// 下载模型
+    /// 创建人：赵耀
+    /// 创建时间：2018年10月30日
+    /// </summary>
+    public class DownloadInfoModel
+    {
+        /// <summary>
+        /// 子线程数量
+        /// </summary>
+        private int _taskCount = 1;
+
+        /// <summary>
+        /// 子线程数量
+        /// </summary>
+        public int taskCount
+        {
+            get => _taskCount;
+            set => _taskCount = value;
+        }
+        /// <summary>
+        /// 保存的临时文件名
+        /// </summary>
+        public string tempFileName { get; set; }
+        /// <summary>
+        /// 是否是新任务，如果不是新任务则通过配置去分配线程
+        /// 一开始要设为true,在初始化完成后会被设为true，此时可以对这个 DownloadInfo 进行序列化后保存，进而实现退出程序加载配置继续下载。
+        /// </summary>
+        private bool _isNewTask = true;
+
+        /// <summary>
+        /// 是否是新任务，如果不是新任务则通过配置去分配线程
+        /// 一开始要设为true,在初始化完成后会被设为true，此时可以对这个 DownloadInfo 进行序列化后保存，进而实现退出程序加载配置继续下载。
+        /// </summary>
+        public bool isNewTask
+        {
+            get => _isNewTask;
+            set => _isNewTask = value;
+        }
+        /// <summary>
+        /// 是否重新下载
+        /// </summary>
+        private bool _isReStart = false;
+
+        /// <summary>
+        /// 是否重新下载
+        /// </summary>
+        public bool isReStart
+        {
+            get => _isReStart;
+            set => _isReStart = value;
+        }
+        /// <summary>
+        /// 任务总大小
+        /// </summary>
+        public long count { get; set; }
+        /// <summary>
+        /// 保存的目录
+        /// </summary>
+        public string saveDir { get; set; }
+        /// <summary>
+        /// 请求方法
+        /// </summary>
+        private string _method = "get";
+
+        /// <summary>
+        /// 请求方法
+        /// </summary>
+        public string method
+        {
+            get => _method;
+            set => _method = value;
+        }
+        /// <summary>
+        /// 文件名
+        /// </summary>
+        public string fileName { get; set; }
+
+        public List<string> _downloadUrlList;
+        /// <summary>
+        /// 下载地址，
+        /// 这里是列表形式，如果同一个文件有不同来源则可以通过不同来源取数据
+        /// 来源的有消息需另外判断
+        /// </summary>
+        public List<string> downloadUrlList
+        {
+            get => _downloadUrlList;
+
+            set
+            {
+                List<string> UTF8ValueList = new List<string>();
+                foreach (string val in value)
+                {
+                    string path = val.Substring(0, val.LastIndexOf("/") + 1);
+                    string name = val.Substring(val.LastIndexOf("/") + 1);
+                    string UTF8Name = System.Web.HttpUtility.UrlEncode(name);
+                    string UTF8Url = path + UTF8Name;
+                    UTF8ValueList.Add(UTF8Url);
+                    _downloadUrlList = UTF8ValueList;
+                }
+                ;
+            }
+        }
+        /// <summary>
+        /// 是否支持断点续传
+        /// 在任务开始后，如果需要暂停，应先通过这个判断是否支持
+        /// 默认设为false
+        /// </summary>
+        private bool _IsSupportMultiThreading = false;
+        /// <summary>
+        /// 是否支持断点续传
+        /// 在任务开始后，如果需要暂停，应先通过这个判断是否支持
+        /// 默认设为false
+        /// </summary>
+        public bool IsSupportMultiThreading
+        {
+            get => _IsSupportMultiThreading;
+            set => _IsSupportMultiThreading = value;
+        }
+        /// <summary>
+        /// 线程任务列表
+        /// </summary>
+        public List<TaskInfoModel> TaskInfoList { get; set; }
+        /// <summary>
+        /// 保存文件名
+        /// </summary>
+        public string saveFileName { get; set; }
+    }
+
+    /// <summary>
+    /// 任务模型
+    /// </summary>
+    public class TaskInfoModel
+    {
+        /// <summary>
+        /// 请求方法
+        /// </summary>
+        public string method { get; set; }
+        public string downloadUrl { get; set; }
+        public string filePath { get; set; }
+        /// <summary>
+        /// 分片起点
+        /// </summary>
+        public long fromIndex { get; set; }
+        /// <summary>
+        /// 分片终点
+        /// </summary>
+        public long toIndex { get; set; }
+        /// <summary>
+        /// 分片的总大小
+        /// </summary>
+        public long count => toIndex - fromIndex + 1;
+    }
+
+    /// <summary>
+    /// 解压书模型
+    /// </summary>
+    public class BookDecompressionModel
+    {
+        /// <summary>
+        /// 书的文件名
+        /// </summary>
+        public string BookFileName { get; set; }
+
+        /// <summary>
+        /// 解压书籍的控件
+        /// </summary>
+        public object UcBookCover { get; set; }
+    }
+}

Common/Properties/AssemblyInfo.cs

@@ -0,0 +1,39 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("Common")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Common")]
+[assembly: AssemblyCopyright("Copyright ©  2020")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// 将 ComVisible 设置为 false 会使此程序集中的类型
+//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
+[assembly: Guid("808a7075-5af5-46b3-8ef6-514c0b5fa8d7")]
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值
+//通过使用 "*"，如下所示:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+
+//Log4Net
+//[assembly: log4net.Config.XmlConfigurator(ConfigFile = "log4net.config", Watch = true)]
+[assembly: log4net.Config.XmlConfigurator(ConfigFile = "log4net.config", ConfigFileExtension = "config", Watch = true)]

Common/ZB/ClippingBorder.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace Common.ZB
+{
+    public class ClippingBorder : Border
+    {
+        private object _oldClip;
+
+        protected override void OnRender(DrawingContext dc)
+        {
+            OnApplyChildClip();
+            base.OnRender(dc);
+        }
+
+        public override UIElement Child
+        {
+            get => base.Child;
+            set
+            {
+                if (Child != value)
+                {
+                    if (Child != null)
+                    {
+                        Child.SetValue(ClipProperty, _oldClip);
+                    }
+
+                    if (value != null)
+                    {
+                        _oldClip = value.ReadLocalValue(ClipProperty);
+                    }
+                    else
+                    {
+                        // If we dont set it to null we could leak a Geometry object
+                        _oldClip = null;
+                    }
+
+                    base.Child = value;
+                }
+            }
+        }
+
+        protected virtual void OnApplyChildClip()
+        {
+            UIElement child = Child;
+            if (child != null)
+            {
+                double top = Math.Max(CornerRadius.TopLeft, CornerRadius.TopRight);
+                double bottom = Math.Max(CornerRadius.BottomLeft, CornerRadius.BottomRight);
+                double max = Math.Max(top, bottom);
+                Size size = RenderSize;
+                double width = size.Width - (BorderThickness.Left + BorderThickness.Right);
+                double height = size.Height - (BorderThickness.Top + BorderThickness.Bottom);
+                Geometry result = new RectangleGeometry(new Rect(0, 0, width, height), max, max);
+                double halfWidth = width / 2;
+                double halfHeight = height / 2;
+
+                if (CornerRadius.TopLeft == 0)
+                {
+                    result = new CombinedGeometry(
+                        GeometryCombineMode.Union,
+                        result,
+                        new RectangleGeometry(new Rect(0, 0, halfWidth, halfHeight))
+                    );
+                }
+
+                if (CornerRadius.TopRight == 0)
+                {
+                    result = new CombinedGeometry(GeometryCombineMode.Union, result, new RectangleGeometry
+                (new Rect(halfWidth, 0, halfWidth, halfHeight)));
+                }
+
+                if (CornerRadius.BottomLeft == 0)
+                {
+                    result = new CombinedGeometry
+                  (GeometryCombineMode.Union, result, new RectangleGeometry
+                  (new Rect(0, halfHeight, halfWidth, halfHeight)));
+                }
+                if (CornerRadius.BottomRight == 0)
+                {
+                    result = new CombinedGeometry
+                  (
+                GeometryCombineMode.Union,
+                result,
+                new RectangleGeometry(new Rect(halfWidth, halfHeight, halfWidth, halfHeight))
+                );
+                }
+                child.Clip = result;
+            }
+        }
+    }
+}

Common/log4net.config

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8" ?>
+  <log4net>
+    <!--错误日志类-->
+    <logger name="logerror">
+      <!--日志类的名字-->
+      <level value="ALL" />
+      <!--定义记录的日志级别-->
+      <appender-ref ref="ErrorAppender" />
+      <!--记录到哪个介质中去-->
+    </logger>
+    <!--信息日志类-->
+    <logger name="loginfo">
+      <level value="ALL" />
+      <appender-ref ref="InfoAppender" />
+    </logger>
+    <!--错误日志附加介质-->
+    <appender name="ErrorAppender" type="log4net.Appender.RollingFileAppender">
+      <!-- name属性指定其名称,type则是log4net.Appender命名空间的一个类的名称,意思是,指定使用哪种介质-->
+      <param name="File" value="Log\\LogError\\" />
+      <!--日志输出到exe程序这个相对目录下-->
+      <param name="AppendToFile" value="true" />
+      <!--输出的日志不会覆盖以前的信息-->
+      <param name="MaxSizeRollBackups" value="100" />
+      <!--备份文件的个数-->
+      <param name="MaxFileSize" value="10240" />
+      <!--当个日志文件的最大大小-->
+      <param name="StaticLogFileName" value="false" />
+      <!--是否使用静态文件名-->
+      <param name="DatePattern" value="yyyyMMdd&quot;.htm&quot;" />
+      <!--日志文件名-->
+      <param name="RollingStyle" value="Date" />
+      <!--文件创建的方式，这里是以Date方式创建-->
+      <!--错误日志布局-->
+      <layout type="log4net.Layout.PatternLayout">
+        <param name="ConversionPattern" value="&lt;HR COLOR=red&gt;%n异常时间：%d [%t] &lt;BR&gt;%n异常级别：%-5p &lt;BR&gt;%n异 常 类：%c [%x] &lt;BR&gt;%n%m &lt;BR&gt;%n &lt;HR Size=1&gt;"  />
+      </layout>
+    </appender>
+    <!--信息日志附加介质-->
+    <appender name="InfoAppender" type="log4net.Appender.RollingFileAppender">
+      <param name="File" value="Log\\LogInfo\\" />
+      <param name="AppendToFile" value="true" />
+      <param name="MaxFileSize" value="10240" />
+      <param name="MaxSizeRollBackups" value="100" />
+      <param name="StaticLogFileName" value="false" />
+      <param name="DatePattern" value="yyyyMMdd&quot;.htm&quot;" />
+      <param name="RollingStyle" value="Date" />
+      <!--信息日志布局-->
+      <layout type="log4net.Layout.PatternLayout">
+        <param name="ConversionPattern" value="&lt;HR COLOR=blue&gt;%n日志时间：%d [%t] &lt;BR&gt;%n日志级别：%-5p &lt;BR&gt;%n日 志 类：%c [%x] &lt;BR&gt;%n%m &lt;BR&gt;%n &lt;HR Size=1&gt;"  />
+      </layout>
+    </appender>
+  </log4net>

Common/packages.config

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="AForge" version="2.2.5" targetFramework="net452" />
+  <package id="AForge.Controls" version="2.2.5" targetFramework="net452" />
+  <package id="AForge.Imaging" version="2.2.5" targetFramework="net452" />
+  <package id="AForge.Math" version="2.2.5" targetFramework="net452" />
+  <package id="AForge.Video" version="2.2.5" targetFramework="net452" />
+  <package id="AForge.Video.DirectShow" version="2.2.5" targetFramework="net452" />
+  <package id="VisioForge.DotNet.Core.TRIAL" version="12.0.56" targetFramework="net452" />
+</packages>

Common/system/BackgroundWorkerHelper.cs

@@ -0,0 +1,114 @@
+using System;
+using System.ComponentModel;
+using System.Threading;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 后台线程帮助类
+    /// </summary>
+    public class BackgroundWorkerHelper : IDisposable
+    {
+        private static BackgroundWorkerHelper backgroundWorkerHelper = null;
+
+        public static BackgroundWorkerHelper GetInstance()
+        {
+            if (backgroundWorkerHelper == null)
+            {
+                backgroundWorkerHelper = new BackgroundWorkerHelper();
+            }
+            return backgroundWorkerHelper;
+        }
+
+        private BackgroundWorker backWorker = null;
+        private Func<object> func = null;
+        private Action<object> actionComplate = null;
+
+        public BackgroundWorkerHelper()
+        {
+            backWorker = new BackgroundWorker();
+            backWorker.DoWork += new DoWorkEventHandler(backWorker_DoWork);
+            backWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backWorker_RunWorkerCompleted);
+        }
+
+        private void backWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
+        {
+            currentThread = null;
+
+            if (e.Error != null)
+            {
+                throw e.Error;
+            }
+            if (actionComplate != null)
+            {
+                actionComplate(e.Result);
+            }
+        }
+
+        private void backWorker_DoWork(object sender, DoWorkEventArgs e)
+        {
+            currentThread = Thread.CurrentThread;
+
+            if (func != null)
+            {
+                if (func != null)
+                {
+                    e.Result = func();
+                }
+            }
+        }
+
+        /// <summary>
+        /// 启动异步线程
+        /// </summary>
+        /// <param name="func">在异步执行的方法</param>
+        /// <param name="action">方法完成后</param>
+        public void RunWorkerAsync(Func<object> func, Action<object> action)
+        {
+            if (!backWorker.IsBusy)
+            {
+                this.func = func;
+                actionComplate = action;
+                backWorker.RunWorkerAsync();
+            }
+        }
+
+        private Thread currentThread = null;
+
+        /// <summary>
+        /// 强制中断
+        /// </summary>
+        public void Abort()
+        {
+            if (currentThread != null && backWorker.IsBusy)
+            {
+                currentThread.Abort();
+                currentThread = null;
+
+                backWorker.DoWork -= backWorker_DoWork;
+                backWorker.RunWorkerCompleted -= backWorker_RunWorkerCompleted;
+                backWorker.Dispose();
+
+                backWorker = new BackgroundWorker();
+                backWorker.DoWork += backWorker_DoWork;
+                backWorker.RunWorkerCompleted += backWorker_RunWorkerCompleted;
+                func = null;
+                actionComplate = null;
+            }
+        }
+
+        #region IDisposable 成员
+
+        /// <summary>
+        /// 释放资源
+        /// </summary>
+        public void Dispose()
+        {
+            actionComplate = null;
+            func = null;
+            backWorker.Dispose();
+        }
+
+        #endregion IDisposable 成员
+    }
+}

Common/system/BlackboardNew.cs

@@ -0,0 +1,304 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Ink;
+using System.Windows.Input;
+using System.Windows.Media;
+
+namespace Common.system
+{
+    internal enum ZPenType : byte
+    {
+        Pen = 1,
+        Erase = 2
+    };
+
+    internal class ZBBPage
+    {
+        public List<ZBBPageStep> lines { get; set; }
+        public List<ZBBPageStep> lines_histoty { get; set; }
+
+        public ZBBPage()
+        {
+            lines = new List<ZBBPageStep>();
+            lines_histoty = new List<ZBBPageStep>();
+        }
+    }
+
+    internal class ZBBPageStep
+    {
+        public StrokeCollection lines_curr { get; set; }
+        public StrokeCollection lines_add { get; set; }
+        public StrokeCollection lines_remove { get; set; }
+
+        public ZBBPageStep()
+        {
+            lines_curr = new StrokeCollection();
+            lines_add = new StrokeCollection();
+            lines_remove = new StrokeCollection();
+        }
+    }
+
+    public class ZJBlackboardNew
+    {
+        private InkCanvas m_canvas;
+
+        //private ZPenType type = ZPenType.Pen;
+        private int pagenum = 0;
+
+        private readonly int erasesize = 64;
+        private readonly int pensize = 3;
+        private int undoOrRedo = 0; //是否在进行撤销恢复操作
+        private Color pencolor;
+
+        private readonly List<ZBBPage> strokes_page_all = new List<ZBBPage>();
+
+        // 添加这个变量是因为在用橡皮擦时 一次操作会触发多次StrokesChanged回掉 这里是把多次回掉合并在一起
+        private ZBBPageStep step = null;
+
+        public ZJBlackboardNew(InkCanvas canvas)
+        {
+            init(canvas, Colors.White);
+        }
+
+        public ZJBlackboardNew(InkCanvas canvas, Color _pencolor)
+        {
+            init(canvas, _pencolor);
+        }
+
+        private void init(InkCanvas canvas, Color _pencolor)
+        {
+            m_canvas = canvas;
+            pencolor = _pencolor;
+            ZBBPage page = new ZBBPage();
+            page.lines.Add(new ZBBPageStep());
+            strokes_page_all.Add(page);
+            if (canvas != null)
+            {
+                canvas.EditingMode = InkCanvasEditingMode.Ink;
+                canvas.UseCustomCursor = true;
+                canvas.Cursor = Cursors.Pen;
+                DrawingAttributes drawingAttributes = new DrawingAttributes();
+                canvas.DefaultDrawingAttributes = drawingAttributes;
+                drawingAttributes.Width = pensize;
+                drawingAttributes.Height = pensize;
+                drawingAttributes.Color = pencolor;
+                drawingAttributes.FitToCurve = true;
+                drawingAttributes.IgnorePressure = false;
+                canvas.Strokes.StrokesChanged += Strokes_StrokesChanged;
+                canvas.StrokeCollected += Canvas_StrokeCollected;
+                canvas.StrokeErasing += Canvas_StrokeErasing;
+                canvas.StrokeErased += Canvas_StrokeErased;
+                canvas.MouseUp += Canvas_MouseUp;
+            }
+        }
+
+        private void Canvas_StrokeErasing(object sender, InkCanvasStrokeErasingEventArgs e)
+        {
+            undoOrRedo = 0;
+        }
+
+        private void Canvas_StrokeErased(object sender, RoutedEventArgs e)
+        {
+        }
+
+        private void Canvas_StrokeCollected(object sender, InkCanvasStrokeCollectedEventArgs e)
+        {
+        }
+
+        private void Canvas_MouseUp(object sender, MouseButtonEventArgs e)
+        {
+            if (step != null)
+            {
+                ZBBPage page = strokes_page_all[pagenum];
+                if (page != null)
+                {
+                    step.lines_curr.Add(m_canvas.Strokes);
+                    page.lines.Add(step);
+                    step = null;
+                }
+            }
+        }
+
+        private void Strokes_StrokesChanged(object sender, StrokeCollectionChangedEventArgs e)
+        {
+            if (undoOrRedo > 0)
+            {
+                undoOrRedo -= 1;
+                return;
+            }
+
+            if (step == null)
+            {
+                step = new ZBBPageStep();
+            }
+
+            // 笔模式
+            if (e.Added.Count > 0 && e.Removed.Count == 0)
+            {
+                step.lines_add.Add(e.Added);
+            }
+            // 橡皮模式 会多次进入回掉
+            else if (e.Removed.Count > 0)
+            {
+                step.lines_add.Add(e.Added);
+                for (int i = 0; i < e.Removed.Count; i++)
+                {
+                    Stroke removeItem = e.Removed[i];
+                    try
+                    {
+                        if (step.lines_add.Contains(removeItem))
+                        {
+                            step.lines_add.Remove(removeItem);
+                        }
+                        else
+                        {
+                            step.lines_remove.Add(removeItem);
+                        }
+                    }
+                    catch (System.Exception ex)
+                    {
+
+                        LogHelper.WriteErrLog("【笔迹添加移除事件】(Strokes_StrokesChanged)" + ex.Message, ex);
+                    }
+                }
+            }
+        }
+
+        // public方法 笔
+        public void change_pen(Color _color, int _size)
+        {
+            //this.type = ZPenType.Pen;
+            DrawingAttributes drawingAttributes = new DrawingAttributes();
+            m_canvas.DefaultDrawingAttributes = drawingAttributes;
+            drawingAttributes.Color = _color;
+            drawingAttributes.Width = _size;
+            drawingAttributes.Height = _size;
+            drawingAttributes.FitToCurve = true;
+            drawingAttributes.IgnorePressure = false;
+            m_canvas.EditingMode = InkCanvasEditingMode.Ink;
+            m_canvas.UseCustomCursor = true;
+            m_canvas.Cursor = Cursors.Pen;
+        }
+
+        // 橡皮
+        public void change_erase()
+        {
+            //this.type = ZPenType.Erase;
+            m_canvas.EditingMode = InkCanvasEditingMode.EraseByPoint;
+            m_canvas.UseCustomCursor = false;
+            m_canvas.EraserShape = new EllipseStylusShape(erasesize, erasesize, 0);
+        }
+
+        // 撤销
+        public void undo()
+        {
+            ZBBPage page = strokes_page_all[pagenum];
+
+            if (page != null && m_canvas.Strokes.Count > 0 && page.lines.Count > 1)
+            {
+                ZBBPageStep last = page.lines.Last();
+                page.lines.Remove(last);
+                page.lines_histoty.Add(last);
+                if (page.lines.Last().lines_curr.Count > 0)
+                {
+                    undoOrRedo = 2;
+                }
+                else
+                {
+                    undoOrRedo = 1;
+                }
+
+                m_canvas.Strokes.Clear();
+                m_canvas.Strokes.Add(page.lines.Last().lines_curr);
+            }
+        }
+
+        // 恢复
+        public void redo()
+        {
+            ZBBPage page = strokes_page_all[pagenum];
+            if (page != null && page.lines_histoty.Count > 0)
+            {
+                ZBBPageStep line = page.lines_histoty[page.lines_histoty.Count - 1];
+
+                page.lines.Add(line);
+                page.lines_histoty.Remove(line);
+                if (page.lines.Last().lines_curr.Count > 0)
+                {
+                    undoOrRedo = 2;
+                }
+                else
+                {
+                    undoOrRedo = 1;
+                }
+                m_canvas.Strokes.Clear();
+                m_canvas.Strokes.Add(page.lines.Last().lines_curr);
+            }
+        }
+
+        // 清空
+        public void clear()
+        {
+            ZBBPage page = strokes_page_all[pagenum];
+            int num = page.lines.Count;
+            for (int i = 0; i < num; i++)
+            {
+                page = strokes_page_all[pagenum];
+                if (page != null && m_canvas.Strokes.Count > 0 && page.lines.Count > 1)
+                {
+                    ZBBPageStep last = page.lines.Last();
+                    page.lines.Remove(last);
+                    page.lines_histoty.Add(last);
+                    if (page.lines.Last().lines_curr.Count > 0)
+                    {
+                        undoOrRedo = 2;
+                    }
+                    else
+                    {
+                        undoOrRedo = 1;
+                    }
+
+                    m_canvas.Strokes.Clear();
+                    m_canvas.Strokes.Add(page.lines.Last().lines_curr);
+                }
+            }
+        }
+
+        public void changepage(int mpagenum)
+        {
+            if (pagenum != mpagenum)
+            {
+                pagenum = mpagenum;
+                if (pagenum >= strokes_page_all.Count)
+                {
+                    int numadd = pagenum - strokes_page_all.Count + 1;
+                    for (int i = 0; i < numadd; i++)
+                    {
+                        ZBBPage pagetemp = new ZBBPage();
+                        pagetemp.lines.Add(new ZBBPageStep());
+                        strokes_page_all.Add(pagetemp);
+                    }
+                }
+
+                ZBBPage page = strokes_page_all[pagenum];
+                if (page != null)
+                {
+                    if (page.lines.Last().lines_curr.Count > 0)
+                    {
+                        undoOrRedo += 1;
+                    }
+                    if (m_canvas.Strokes.Count > 0)
+                    {
+                        undoOrRedo += 1;
+                        m_canvas.Strokes.Clear();
+                    }
+
+                    m_canvas.Strokes.Add(page.lines.Last().lines_curr);
+                }
+            }
+        }
+    }
+}

Common/system/CLeopardZip.cs

@@ -0,0 +1,701 @@
+using ICSharpCode.SharpZipLib.Checksums;
+using ICSharpCode.SharpZipLib.Zip;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Common.system
+{
+    /// <summary>   
+    /// 适用与ZIP压缩   
+    /// </summary>   
+    public class ZipHelper
+    {
+        #region 压缩
+
+        /// <summary>   
+        /// 递归压缩文件夹的内部方法   
+        /// </summary>   
+        /// <param name="folderToZip">要压缩的文件夹路径</param>   
+        /// <param name="zipStream">压缩输出流</param>   
+        /// <param name="parentFolderName">此文件夹的上级文件夹</param>   
+        /// <returns></returns>   
+        private static bool ZipDirectory(string folderToZip, ZipOutputStream zipStream, string parentFolderName)
+        {
+            bool result = true;
+            string[] folders, files;
+            ZipEntry ent = null;
+            FileStream fs = null;
+            Crc32 crc = new Crc32();
+
+            try
+            {
+                ent = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/"));
+                zipStream.PutNextEntry(ent);
+                zipStream.Flush();
+
+                files = Directory.GetFiles(folderToZip);
+                foreach (string file in files)
+                {
+                    fs = File.OpenRead(file);
+
+                    byte[] buffer = new byte[fs.Length];
+                    fs.Read(buffer, 0, buffer.Length);
+                    ent = new ZipEntry(Path.Combine(parentFolderName, Path.GetFileName(folderToZip) + "/" + Path.GetFileName(file)))
+                    {
+                        DateTime = DateTime.Now,
+                        Size = fs.Length
+                    };
+
+                    fs.Close();
+
+                    crc.Reset();
+                    crc.Update(buffer);
+
+                    ent.Crc = crc.Value;
+                    zipStream.PutNextEntry(ent);
+                    zipStream.Write(buffer, 0, buffer.Length);
+                }
+
+            }
+            catch
+            {
+                result = false;
+            }
+            finally
+            {
+                if (fs != null)
+                {
+                    fs.Close();
+                    fs.Dispose();
+                }
+                if (ent != null)
+                {
+                    ent = null;
+                }
+                GC.Collect();
+                GC.Collect(1);
+            }
+
+            folders = Directory.GetDirectories(folderToZip);
+            foreach (string folder in folders)
+            {
+                if (!ZipDirectory(folder, zipStream, folderToZip))
+                {
+                    return false;
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>   
+        /// 压缩文件夹    
+        /// </summary>   
+        /// <param name="folderToZip">要压缩的文件夹路径</param>   
+        /// <param name="zipedFile">压缩文件完整路径</param>   
+        /// <param name="password">密码</param>   
+        /// <returns>是否压缩成功</returns>   
+        public static bool ZipDirectory(string folderToZip, string zipedFile, string password)
+        {
+            bool result = false;
+            if (!Directory.Exists(folderToZip))
+            {
+                return result;
+            }
+
+            ZipOutputStream zipStream = new ZipOutputStream(File.Create(zipedFile));
+            zipStream.SetLevel(6);
+            if (!string.IsNullOrEmpty(password))
+            {
+                zipStream.Password = password;
+            }
+
+            result = ZipDirectory(folderToZip, zipStream, "");
+
+            zipStream.Finish();
+            zipStream.Close();
+
+            return result;
+        }
+
+        /// <summary>   
+        /// 压缩文件夹   
+        /// </summary>   
+        /// <param name="folderToZip">要压缩的文件夹路径</param>   
+        /// <param name="zipedFile">压缩文件完整路径</param>   
+        /// <returns>是否压缩成功</returns>   
+        public static bool ZipDirectory(string folderToZip, string zipedFile)
+        {
+            bool result = ZipDirectory(folderToZip, zipedFile, null);
+            return result;
+        }
+
+        /// <summary>   
+        /// 压缩文件   
+        /// </summary>   
+        /// <param name="fileToZip">要压缩的文件全名</param>   
+        /// <param name="zipedFile">压缩后的文件名</param>   
+        /// <param name="password">密码</param>   
+        /// <returns>压缩结果</returns>   
+        public static bool ZipFile(string fileToZip, string zipedFile, string password)
+        {
+            bool result = true;
+            ZipOutputStream zipStream = null;
+            FileStream fs = null;
+            ZipEntry ent = null;
+
+            if (!File.Exists(fileToZip))
+            {
+                return false;
+            }
+
+            try
+            {
+                fs = File.OpenRead(fileToZip);
+                byte[] buffer = new byte[fs.Length];
+                fs.Read(buffer, 0, buffer.Length);
+                fs.Close();
+
+                fs = File.Create(zipedFile);
+                zipStream = new ZipOutputStream(fs);
+                if (!string.IsNullOrEmpty(password))
+                {
+                    zipStream.Password = password;
+                }
+
+                ent = new ZipEntry(Path.GetFileName(fileToZip));
+                zipStream.PutNextEntry(ent);
+                zipStream.SetLevel(6);
+
+                zipStream.Write(buffer, 0, buffer.Length);
+
+            }
+            catch
+            {
+                result = false;
+            }
+            finally
+            {
+                if (zipStream != null)
+                {
+                    zipStream.Finish();
+                    zipStream.Close();
+                }
+                if (ent != null)
+                {
+                    ent = null;
+                }
+                if (fs != null)
+                {
+                    fs.Close();
+                    fs.Dispose();
+                }
+            }
+            GC.Collect();
+            GC.Collect(1);
+
+            return result;
+        }
+
+        /// <summary>   
+        /// 压缩文件   
+        /// </summary>   
+        /// <param name="fileToZip">要压缩的文件全名</param>   
+        /// <param name="zipedFile">压缩后的文件名</param>   
+        /// <returns>压缩结果</returns>   
+        public static bool ZipFile(string fileToZip, string zipedFile)
+        {
+            bool result = ZipFile(fileToZip, zipedFile, null);
+            return result;
+        }
+
+        /// <summary>   
+        /// 压缩文件或文件夹   
+        /// </summary>   
+        /// <param name="fileToZip">要压缩的路径</param>   
+        /// <param name="zipedFile">压缩后的文件名</param>   
+        /// <param name="password">密码</param>   
+        /// <returns>压缩结果</returns>   
+        public static bool Zip(string fileToZip, string zipedFile, string password)
+        {
+            bool result = false;
+            if (Directory.Exists(fileToZip))
+            {
+                result = ZipDirectory(fileToZip, zipedFile, password);
+            }
+            else if (File.Exists(fileToZip))
+            {
+                result = ZipFile(fileToZip, zipedFile, password);
+            }
+
+            return result;
+        }
+
+        /// <summary>   
+        /// 压缩文件或文件夹   
+        /// </summary>   
+        /// <param name="fileToZip">要压缩的路径</param>   
+        /// <param name="zipedFile">压缩后的文件名</param>   
+        /// <returns>压缩结果</returns>   
+        public static bool Zip(string fileToZip, string zipedFile)
+        {
+            bool result = Zip(fileToZip, zipedFile, null);
+            return result;
+
+        }
+
+        #endregion
+
+        #region 解压
+
+        /// <summary>   
+        /// 解压功能(解压压缩文件到指定目录)   
+        /// </summary>   
+        /// <param name="fileToUnZip">待解压的文件</param>   
+        /// <param name="zipedFolder">指定解压目标目录</param>   
+        /// <param name="password">密码</param>   
+        /// <returns>解压结果</returns>   
+        public static bool UnZip(string fileToUnZip, string zipedFolder, string password)
+        {
+            bool result = true;
+            FileStream fs = null;
+            ZipInputStream zipStream = null;
+            ZipEntry ent = null;
+            string fileName;
+
+            if (!File.Exists(fileToUnZip))
+            {
+                return false;
+            }
+
+            if (!Directory.Exists(zipedFolder))
+            {
+                Directory.CreateDirectory(zipedFolder);
+            }
+
+            try
+            {
+                zipStream = new ZipInputStream(File.OpenRead(fileToUnZip));
+                if (!string.IsNullOrEmpty(password))
+                {
+                    zipStream.Password = password;
+                }
+
+                while ((ent = zipStream.GetNextEntry()) != null)
+                {
+                    if (!string.IsNullOrEmpty(ent.Name))
+                    {
+                        fileName = Path.Combine(zipedFolder, ent.Name);
+                        fileName = fileName.Replace('/', '\\');//change by Mr.HopeGi   
+
+                        if (fileName.EndsWith("\\"))
+                        {
+                            Directory.CreateDirectory(fileName);
+                            continue;
+                        }
+
+                        fs = File.Create(fileName);
+                        int size = 2048;
+                        byte[] data = new byte[size];
+                        while (true)
+                        {
+                            size = zipStream.Read(data, 0, data.Length);
+                            if (size > 0)
+                            {
+                                fs.Write(data, 0, data.Length);
+                            }
+                            else
+                            {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            catch
+            {
+                result = false;
+            }
+            finally
+            {
+                if (fs != null)
+                {
+                    fs.Close();
+                    fs.Dispose();
+                }
+                if (zipStream != null)
+                {
+                    zipStream.Close();
+                    zipStream.Dispose();
+                }
+                if (ent != null)
+                {
+                    ent = null;
+                }
+                GC.Collect();
+                GC.Collect(1);
+            }
+            return result;
+        }
+
+        /// <summary>   
+        /// 解压功能(解压压缩文件到指定目录)   
+        /// </summary>   
+        /// <param name="fileToUnZip">待解压的文件</param>   
+        /// <param name="zipedFolder">指定解压目标目录</param>   
+        /// <returns>解压结果</returns>   
+        public static bool UnZip(string fileToUnZip, string zipedFolder)
+        {
+            bool result = NewUnZip(fileToUnZip, zipedFolder, null, true);
+            return result;
+        }
+
+        /// <summary>
+        /// ZIP:解压一个zip文件
+        /// </summary>
+        /// <param name="ZipFile">需要解压的Zip文件（绝对路径）</param>
+        /// <param name="TargetDirectory">解压到的目录</param>
+        /// <param name="Password">解压密码</param>
+        /// <param name="OverWrite">是否覆盖已存在的文件</param>
+        public static bool NewUnZip(string ZipFile, string TargetDirectory, string Password, bool OverWrite = true)
+        {
+            try
+            {
+
+                //如果解压到的目录不存在，则报错
+                if (!System.IO.Directory.Exists(TargetDirectory))
+                {
+                    throw new System.IO.FileNotFoundException("指定的目录: " + TargetDirectory + " 不存在!");
+                }
+                //目录结尾
+                if (!TargetDirectory.EndsWith("\\")) { TargetDirectory = TargetDirectory + "\\"; }
+
+                using (ZipInputStream zipfiles = new ZipInputStream(File.OpenRead(ZipFile)))
+                {
+                    zipfiles.Password = Password;
+                    ZipEntry theEntry;
+
+                    while ((theEntry = zipfiles.GetNextEntry()) != null)
+                    {
+                        string directoryName = "";
+                        string pathToZip = "";
+                        pathToZip = theEntry.Name;
+
+                        if (pathToZip != "")
+                        {
+                            directoryName = Path.GetDirectoryName(pathToZip) + "\\";
+                        }
+
+                        string fileName = Path.GetFileName(pathToZip);
+
+                        Directory.CreateDirectory(TargetDirectory + directoryName);
+
+                        if (fileName != "")
+                        {
+                            if ((File.Exists(TargetDirectory + directoryName + fileName) && OverWrite) || (!File.Exists(TargetDirectory + directoryName + fileName)))
+                            {
+                                try
+                                {
+                                    using (FileStream streamWriter = File.Create(TargetDirectory + directoryName + fileName))
+                                    {
+                                        int size = 2048;
+                                        byte[] data = new byte[2048];
+                                        while (true)
+                                        {
+                                            size = zipfiles.Read(data, 0, data.Length);
+
+                                            if (size > 0)
+                                            {
+                                                streamWriter.Write(data, 0, size);
+                                            }
+                                            else
+                                            {
+                                                break;
+                                            }
+                                        }
+                                        streamWriter.Close();
+                                    }
+                                }
+                                catch (Exception ex)
+                                {
+                                    string message = ex.Message;
+                                    //解压出错//若文件无损坏则可能为无法覆盖文件
+                                }
+                            }
+                        }
+                    }
+
+                    zipfiles.Close();
+                }
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+        #endregion
+
+
+        #region 压缩文件
+        /// <summary>    
+        /// 压缩文件    
+        /// </summary>    
+        /// <param name="fileNames">要打包的文件列表</param>    
+        /// <param name="GzipFileName">目标文件名</param>    
+        /// <param name="CompressionLevel">压缩品质级别（0~9）</param>    
+        /// <param name="deleteFile">是否删除原文件</param>  
+        public static void CompressFile(List<FileInfo> fileNames, string GzipFileName, int CompressionLevel, bool deleteFile)
+        {
+            ZipOutputStream s = new ZipOutputStream(File.Create(GzipFileName));
+            try
+            {
+                s.SetLevel(CompressionLevel);   //0 - store only to 9 - means best compression    
+                foreach (FileInfo file in fileNames)
+                {
+                    FileStream fs = null;
+                    try
+                    {
+                        fs = file.Open(FileMode.Open, FileAccess.ReadWrite);
+                    }
+                    catch
+                    { continue; }
+                    //  方法二，将文件分批读入缓冲区    
+                    byte[] data = new byte[2048];
+                    int size = 2048;
+                    ZipEntry entry = new ZipEntry(Path.GetFileName(file.Name))
+                    {
+                        DateTime = (file.CreationTime > file.LastWriteTime ? file.LastWriteTime : file.CreationTime)
+                    };
+                    s.PutNextEntry(entry);
+                    while (true)
+                    {
+                        size = fs.Read(data, 0, size);
+                        if (size <= 0)
+                        {
+                            break;
+                        }
+
+                        s.Write(data, 0, size);
+                    }
+                    fs.Close();
+                    if (deleteFile)
+                    {
+                        file.Delete();
+                    }
+                }
+            }
+            finally
+            {
+                s.Finish();
+                s.Close();
+            }
+        }
+        public static void CompressFile(string fileName, string GzipFileName, int CompressionLevel, bool deleteFile)
+        {
+            ZipOutputStream s = new ZipOutputStream(File.Create(GzipFileName));
+            try
+            {
+                s.SetLevel(CompressionLevel);   //0 - store only to 9 - means best compression    
+                FileInfo file = new FileInfo(fileName);
+                FileStream fs = null;
+                try
+                {
+                    fs = file.Open(FileMode.Open, FileAccess.ReadWrite);
+                }
+                catch
+                { return; }
+                //  方法二，将文件分批读入缓冲区    
+                byte[] data = new byte[2048];
+                int size = 2048;
+                ZipEntry entry = new ZipEntry(Path.GetFileName(file.Name))
+                {
+                    DateTime = (file.CreationTime > file.LastWriteTime ? file.LastWriteTime : file.CreationTime)
+                };
+                s.PutNextEntry(entry);
+                while (true)
+                {
+                    size = fs.Read(data, 0, size);
+                    if (size <= 0)
+                    {
+                        break;
+                    }
+
+                    s.Write(data, 0, size);
+                }
+                fs.Close();
+                if (deleteFile)
+                {
+                    file.Delete();
+                }
+            }
+            finally
+            {
+                s.Finish();
+                s.Close();
+            }
+        }
+        /// <summary>    
+        /// 压缩文件夹    
+        /// </summary>    
+        /// <param name="dirPath">要打包的文件夹</param>    
+        /// <param name="GzipFileName">目标文件名</param>    
+        /// <param name="CompressionLevel">压缩品质级别（0~9）</param>    
+        /// <param name="deleteDir">是否删除原文件夹</param>  
+        public static void CompressDirectory(string dirPath, string GzipFileName, int CompressionLevel, bool deleteDir)
+        {
+            //压缩文件为空时默认与压缩文件夹同一级目录    
+            if (GzipFileName == string.Empty)
+            {
+                GzipFileName = dirPath.Substring(dirPath.LastIndexOf("//") + 1);
+                GzipFileName = dirPath.Substring(0, dirPath.LastIndexOf("//")) + "//" + GzipFileName + ".zip";
+            }
+            //if (Path.GetExtension(GzipFileName) != ".zip")  
+            //{  
+            //    GzipFileName = GzipFileName + ".zip";  
+            //}  
+            using (ZipOutputStream zipoutputstream = new ZipOutputStream(File.Create(GzipFileName)))
+            {
+                zipoutputstream.SetLevel(CompressionLevel);
+                Crc32 crc = new Crc32();
+                Dictionary<string, DateTime> fileList = GetAllFies(dirPath);
+                foreach (KeyValuePair<string, DateTime> item in fileList)
+                {
+                    FileStream fs = File.OpenRead(item.Key.ToString());
+                    byte[] buffer = new byte[fs.Length];
+                    fs.Read(buffer, 0, buffer.Length);
+                    ZipEntry entry = new ZipEntry(item.Key.Substring(dirPath.Length))
+                    {
+                        DateTime = item.Value,
+                        Size = fs.Length
+                    };
+                    fs.Close();
+                    crc.Reset();
+                    crc.Update(buffer);
+                    entry.Crc = crc.Value;
+                    zipoutputstream.PutNextEntry(entry);
+                    zipoutputstream.Write(buffer, 0, buffer.Length);
+                }
+            }
+            if (deleteDir)
+            {
+                Directory.Delete(dirPath, true);
+            }
+        }
+        /// <summary>    
+        /// 获取所有文件    
+        /// </summary>    
+        /// <returns></returns>    
+        private static Dictionary<string, DateTime> GetAllFies(string dir)
+        {
+            Dictionary<string, DateTime> FilesList = new Dictionary<string, DateTime>();
+            DirectoryInfo fileDire = new DirectoryInfo(dir);
+            if (!fileDire.Exists)
+            {
+                throw new System.IO.FileNotFoundException("目录:" + fileDire.FullName + "没有找到!");
+            }
+            GetAllDirFiles(fileDire, FilesList);
+            GetAllDirsFiles(fileDire.GetDirectories(), FilesList);
+            return FilesList;
+        }
+        /// <summary>    
+        /// 获取一个文件夹下的所有文件夹里的文件    
+        /// </summary>    
+        /// <param name="dirs"></param>    
+        /// <param name="filesList"></param>    
+        private static void GetAllDirsFiles(DirectoryInfo[] dirs, Dictionary<string, DateTime> filesList)
+        {
+            foreach (DirectoryInfo dir in dirs)
+            {
+                foreach (FileInfo file in dir.GetFiles("*.*"))
+                {
+                    filesList.Add(file.FullName, file.LastWriteTime);
+                }
+                GetAllDirsFiles(dir.GetDirectories(), filesList);
+            }
+        }
+        /// <summary>    
+        /// 获取一个文件夹下的文件    
+        /// </summary>    
+        /// <param name="dir">目录名称</param>    
+        /// <param name="filesList">文件列表HastTable</param>    
+        private static void GetAllDirFiles(DirectoryInfo dir, Dictionary<string, DateTime> filesList)
+        {
+            foreach (FileInfo file in dir.GetFiles("*.*"))
+            {
+                filesList.Add(file.FullName, file.LastWriteTime);
+            }
+        }
+        #endregion
+
+        #region 解压缩文件
+        /// <summary>    
+        /// 解压缩文件    
+        /// </summary>    
+        /// <param name="GzipFile">压缩包文件名</param>    
+        /// <param name="targetPath">解压缩目标路径</param>           
+        public static void Decompress(string GzipFile, string targetPath)
+        {
+            //string directoryName = Path.GetDirectoryName(targetPath + "//") + "//";    
+            string directoryName = targetPath;
+            if (!Directory.Exists(directoryName))
+            {
+                Directory.CreateDirectory(directoryName);//生成解压目录    
+            }
+
+            string CurrentDirectory = directoryName;
+            byte[] data = new byte[2048];
+            int size = 2048;
+            ZipEntry theEntry = null;
+            using (ZipInputStream s = new ZipInputStream(File.OpenRead(GzipFile)))
+            {
+                while ((theEntry = s.GetNextEntry()) != null)
+                {
+                    if (theEntry.IsDirectory)
+                    {// 该结点是目录    
+                        if (!Directory.Exists(CurrentDirectory + theEntry.Name))
+                        {
+                            Directory.CreateDirectory(CurrentDirectory + theEntry.Name);
+                        }
+                    }
+                    else
+                    {
+                        if (theEntry.Name != string.Empty)
+                        {
+                            //  检查多级目录是否存在  
+                            if (theEntry.Name.Contains("\\"))
+                            {
+                                string parentDirPath = theEntry.Name.Remove(theEntry.Name.LastIndexOf("\\") + 1);
+                                if (!Directory.Exists(parentDirPath))
+                                {
+                                    Directory.CreateDirectory(CurrentDirectory + parentDirPath);
+                                }
+                            }
+
+                            //解压文件到指定的目录    
+                            using (FileStream streamWriter = File.Create(CurrentDirectory + theEntry.Name))
+                            {
+                                while (true)
+                                {
+                                    size = s.Read(data, 0, data.Length);
+                                    if (size <= 0)
+                                    {
+                                        break;
+                                    }
+
+                                    streamWriter.Write(data, 0, size);
+                                }
+                                streamWriter.Close();
+                            }
+                        }
+                    }
+                }
+                s.Close();
+            }
+        }
+        #endregion
+
+    }
+}

Common/system/DataConvertCommon.cs

@@ -0,0 +1,36 @@
+namespace Common.system
+{
+    /// <summary>
+    /// 数据转换帮助类
+    /// 创建人：赵耀
+    /// 创建时间：2018年10月24日
+    /// </summary>
+    public class DataConvertCommon
+    {
+        /// <summary>
+        /// 父类向子类赋值
+        /// 创建人：赵耀
+        /// 创建时间：2018年10月24日
+        /// </summary>
+        /// <typeparam name="TParent">父类</typeparam>
+        /// <typeparam name="TChild">子类</typeparam>
+        /// <param name="parent">子数据</param>
+        /// <returns></returns>
+        public static TChild ParentClassCopy<TParent, TChild>(TParent parent) where TChild : TParent, new()
+        {
+            TChild child = new TChild();
+            System.Type ParentType = typeof(TParent);
+            System.Reflection.PropertyInfo[] Properties = ParentType.GetProperties();
+            foreach (System.Reflection.PropertyInfo Propertie in Properties)
+            {
+                //循环遍历属性
+                if (Propertie.CanRead && Propertie.CanWrite)
+                {
+                    //进行属性拷贝
+                    Propertie.SetValue(child, Propertie.GetValue(parent, null), null);
+                }
+            }
+            return child;
+        }
+    }
+}

Common/system/DataProvider.cs

@@ -0,0 +1,100 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Common.system
+{
+    public class DataProvider
+    {
+        ///3DES解密   
+        public static string TripleDESDecrypt(string pToDecrypt, string sKey)
+        {
+            sKey = sKey.Substring(0, 24);
+            TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider
+            {
+                Mode = CipherMode.ECB,
+                Padding = PaddingMode.Zeros
+            };
+            byte[] inputByteArray = new byte[pToDecrypt.Length / 2];
+            for (int x = 0; x < pToDecrypt.Length / 2; x++)
+            {
+                int i = (Convert.ToInt32(pToDecrypt.Substring(x * 2, 2), 16));
+                inputByteArray[x] = (byte)i;
+            }
+
+            des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
+            des.IV = new byte[] { 0, 00, 00, 00, 00, 00, 00, 00, };
+            MemoryStream ms = new MemoryStream();
+            CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
+            cs.Write(inputByteArray, 0, inputByteArray.Length);
+            cs.FlushFinalBlock();
+
+            StringBuilder ret = new StringBuilder();
+
+            return System.Text.Encoding.Default.GetString(ms.ToArray()).Replace("\0", "");
+        }
+        /// <summary>
+        /// 返回一个时间戳到秒
+        /// </summary>
+        /// <returns></returns>
+        public static long TimestampTotalSeconds()
+        {
+            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
+            long timestr = Convert.ToInt64(ts.TotalSeconds);
+            return timestr;
+        }
+        /// <summary>
+        /// 将字典类型序列化为json字符串
+        /// </summary>
+        /// <typeparam name="TKey">字典key</typeparam>
+        /// <typeparam name="TValue">字典value</typeparam>
+        /// <param name="dict">要序列化的字典数据</param>
+        /// <returns>json字符串</returns>
+        public static string SerializeDictionaryToJsonString<TKey, TValue>(Dictionary<TKey, TValue> dict)
+        {
+            if (dict.Count == 0)
+            {
+                return "";
+            }
+
+            string jsonStr = JsonConvert.SerializeObject(dict);
+            return jsonStr;
+        }
+        /// <summary>
+        ///调用Post接口
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public static string HttpPost(string body, string Url)
+        {
+            try
+            {
+                Encoding encoding = Encoding.UTF8;
+
+                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
+                request.Method = "POST";
+                request.Accept = "text/html,application/xhtml+xml,*/*";
+                request.ContentType = "application/json";
+
+                byte[] buffer = encoding.GetBytes(body);
+                request.ContentLength = buffer.Length;
+                request.GetRequestStream().Write(buffer, 0, buffer.Length);
+
+                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
+                using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
+                {
+                    return reader.ReadToEnd();
+                }
+            }
+            catch (Exception ex)
+            {
+                // LogHelper.Instance.Debug($"POST接口连接失败，请求参数：{ex.Message}");
+                return "POST报错:" + ex.Message;
+            }
+        }
+    }
+}

Common/system/DownloadManager.cs

@@ -0,0 +1,411 @@
+using Common.Model;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 下载方法
+    /// 创建人：赵耀
+    /// 创建时间：2018年10月30日
+    /// </summary>
+    public class DownloadManager
+    {
+        private long fromIndex = 0;//开始下载的位置
+        private bool isRun = false;//是否正在进行
+        private DownloadInfoModel dlInfo;
+
+        private List<DownloadService> dls = new List<DownloadService>();
+        /// <summary>
+        /// 开始下载
+        /// </summary>
+        public event Action OnStart;
+        /// <summary>
+        /// 停止下载
+        /// </summary>
+        public event Action OnStop;
+        /// <summary>
+        /// 下载进度
+        /// </summary>
+        public event Action<long, long, string> OnDownload;
+        /// <summary>
+        /// 下载完成
+        /// </summary>
+        public event Action<string> OnFinsh;
+        /// <summary>
+        /// 断开网络连接
+        /// </summary>
+        public event Action<string> OnDisconnect;
+
+        public DownloadManager(DownloadInfoModel dlInfo)
+        {
+            this.dlInfo = dlInfo;
+        }
+        /// <summary>
+        /// 暂停
+        /// </summary>
+        public void Stop()
+        {
+            isRun = false;
+            dls.ForEach(dl => dl.Stop());
+            OnStopHandler();
+        }
+        /// <summary>
+        /// 开始下载
+        /// </summary>
+        public void Start()
+        {
+            dlInfo.isReStart = false;
+            WorkStart();
+        }
+        /// <summary>
+        /// 重新下载
+        /// </summary>
+        public void ReStart()
+        {
+            dlInfo.isReStart = true;
+            WorkStart();
+        }
+        /// <summary>
+        /// 下载
+        /// </summary>
+        private void WorkStart()
+        {
+            new Action(() =>
+            {
+                if (dlInfo.isReStart)
+                {
+                    Stop();
+                }
+
+                while (dls.Where(dl => !dl.isStopped).Count() > 0)
+                {
+                    if (dlInfo.isReStart)
+                    {
+                        Thread.Sleep(100);
+                    }
+                    else
+                    {
+                        return;
+                    }
+                }
+
+                isRun = true;
+                OnStartHandler();
+                //首次任务或者不支持断点续传的进入
+                if (dlInfo.isNewTask || (!dlInfo.isNewTask && !dlInfo.IsSupportMultiThreading))
+                {
+                    try
+                    {
+                        //第一次请求获取一小块数据，根据返回的情况判断是否支持断点续传
+                        using (System.Net.WebResponse rsp = HttpHelper.Download(dlInfo.downloadUrlList[0], 0, 0, dlInfo.method))
+                        {
+
+                            //获取文件名，如果包含附件名称则取下附件，否则从url获取名称
+                            string Disposition = rsp.Headers["Content-Disposition"];
+                            try
+                            {
+                                if (Disposition != null)
+                                {
+                                    dlInfo.fileName = Disposition.Split('=')[1];
+                                }
+                                else
+                                {
+                                    dlInfo.fileName = Path.GetFileName(rsp.ResponseUri.AbsolutePath);
+                                }
+                            }
+                            catch (Exception)//无法获取文件名时  使用传入保存名称
+                            {
+                                dlInfo.fileName = dlInfo.saveFileName;
+                            }
+
+                            //默认给流总数
+                            dlInfo.count = rsp.ContentLength;
+                            //尝试获取 Content-Range 头部，不为空说明支持断点续传
+                            string contentRange = rsp.Headers["Content-Range"];
+                            if (contentRange != null)
+                            {
+                                //支持断点续传的话，就取range 这里的总数
+                                dlInfo.count = long.Parse(rsp.Headers["Content-Range"].Split('/')[1]);
+                                dlInfo.IsSupportMultiThreading = true;
+
+                                //生成一个临时文件名
+                                //var tempFileName = Convert.ToBase64String(Encoding.UTF8.GetBytes(dlInfo.fileName)).ToUpper();
+                                //tempFileName = tempFileName.Length > 32 ? tempFileName.Substring(0, 32) : tempFileName;
+                                //dlInfo.tempFileName = "test"; //tempFileName + DateTime.Now.ToString("yyyyMMddHHmmssfff");
+                                ///创建线程信息
+                                ///
+                                GetTaskInfo(dlInfo);
+
+                            }
+                            else
+                            {
+                                //不支持断点续传则一开始就直接读完整流
+                                Save(GetRealFileName(dlInfo), rsp.GetResponseStream());
+                                OnFineshHandler();
+                            }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        string ErrMessage = "【下载】(DownloadManager):" + ex.Message;
+                        LogHelper.WriteErrLog(ErrMessage, ex);
+                        OnDisconnectHandler();
+                        return;
+                    }
+                    dlInfo.isNewTask = false;
+                }
+                //如果支持断点续传采用这个
+                if (dlInfo.IsSupportMultiThreading)
+                {
+                    StartTask(dlInfo);
+
+                    //等待合并
+                    while (dls.Where(td => !td.isFinish).Count() > 0 && isRun)
+                    {
+                        Thread.Sleep(100);
+                    }
+                    if ((dls.Where(td => !td.isFinish).Count() == 0))
+                    {
+
+                        CombineFiles(dlInfo);
+                        OnFineshHandler();
+                    }
+                }
+
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 合成文件
+        /// </summary>
+        /// <param name="dlInfo"></param>
+        private void CombineFiles(DownloadInfoModel dlInfo)
+        {
+            string realFilePath = GetRealFileName(dlInfo);
+
+            //合并数据
+            byte[] buffer = new byte[2048];
+            int length = 0;
+            using (FileStream fileStream = File.Open(realFilePath, FileMode.CreateNew))
+            {
+                for (int i = 0; i < dlInfo.TaskInfoList.Count; i++)
+                {
+                    string tempFile = dlInfo.TaskInfoList[i].filePath;
+                    using (FileStream tempStream = File.Open(tempFile, FileMode.Open))
+                    {
+                        while ((length = tempStream.Read(buffer, 0, buffer.Length)) > 0)
+                        {
+                            fileStream.Write(buffer, 0, length);
+                        }
+                        tempStream.Flush();
+                    }
+                    //File.Delete(tempFile);
+                }
+            }
+        }
+        /// <summary>
+        /// 创建文件
+        /// </summary>
+        /// <param name="dlInfo"></param>
+        /// <returns></returns>
+        private static string GetRealFileName(DownloadInfoModel dlInfo)
+        {
+            //创建正式文件名，如果已存在则加数字序号创建，避免覆盖
+            int fileIndex = 0;
+            string realFilePath = Path.Combine(dlInfo.saveDir, dlInfo.saveFileName);
+            while (File.Exists(realFilePath))
+            {
+                realFilePath = Path.Combine(dlInfo.saveDir, string.Format("{0}_{1}", fileIndex++, dlInfo.fileName));
+            }
+
+            return realFilePath;
+        }
+
+        private void StartTask(DownloadInfoModel dlInfo)
+        {
+            dls = new List<DownloadService>();
+            if (dlInfo.TaskInfoList != null)
+            {
+                foreach (TaskInfoModel item in dlInfo.TaskInfoList)
+                {
+                    DownloadService dl = new DownloadService();
+                    dl.OnDownload += OnDownloadHandler;
+                    dl.OnDisconnect += OnDisconnectHandler;
+                    dls.Add(dl);
+                    try
+                    {
+                        dl.Start(item, dlInfo.isReStart);
+                    }
+                    catch (Exception ex)
+                    {
+                        string ErrMessage = "【下载】(DownloadManager):" + ex.Message;
+                        LogHelper.WriteErrLog(ErrMessage, ex);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// 创建下载任务
+        /// </summary>
+        /// <param name="dlInfo"></param>
+        private void GetTaskInfo(DownloadInfoModel dlInfo)
+        {
+            long pieceSize = (dlInfo.count) / dlInfo.taskCount;
+            dlInfo.TaskInfoList = new List<TaskInfoModel>();
+            Random rand = new Random();
+            int urlIndex = 0;
+            for (int i = 0; i <= dlInfo.taskCount + 1; i++)
+            {
+                long from = (i * pieceSize);
+
+                if (from >= dlInfo.count)
+                {
+                    break;
+                }
+
+                long to = from + pieceSize;
+                if (to >= dlInfo.count)
+                {
+                    to = dlInfo.count;
+                }
+
+                dlInfo.TaskInfoList.Add(
+                    new TaskInfoModel
+                    {
+                        method = dlInfo.method,
+                        downloadUrl = dlInfo.downloadUrlList[urlIndex++],
+
+                        filePath = Path.Combine(dlInfo.saveDir, dlInfo.tempFileName + ".temp" + i),
+                        fromIndex = from,
+                        toIndex = to
+                    });
+                if (urlIndex >= dlInfo.downloadUrlList.Count)
+                {
+                    urlIndex = 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 保存内容
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="stream"></param>
+        private void Save(string filePath, Stream stream)
+        {
+            try
+            {
+                using (FileStream writer = File.Open(filePath, FileMode.Append))
+                {
+                    using (stream)
+                    {
+                        int repeatTimes = 0;
+                        byte[] buffer = new byte[1024];
+                        int length = 0;
+                        while ((length = stream.Read(buffer, 0, buffer.Length)) > 0 && isRun)
+                        {
+                            writer.Write(buffer, 0, length);
+                            fromIndex += length;
+                            if (repeatTimes % 5 == 0)
+                            {
+                                writer.Flush();//一定大小就刷一次缓冲区
+                                OnDownloadHandler();
+                            }
+                            repeatTimes++;
+                        }
+                        writer.Flush();
+                        OnDownloadHandler();
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                //异常也不影响
+            }
+        }
+
+        /// <summary>
+        /// 开始下载
+        /// </summary>
+        private void OnStartHandler()
+        {
+            new Action(() =>
+            {
+                OnStart.Invoke();
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 暂停下载
+        /// </summary>
+        private void OnStopHandler()
+        {
+            new Action(() =>
+            {
+                OnStop.Invoke();
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 下载完成
+        /// </summary>
+        private void OnFineshHandler()
+        {
+            new Action(() =>
+            {
+                for (int i = 0; i < dlInfo.TaskInfoList.Count; i++)
+                {
+                    string tempFile = dlInfo.TaskInfoList[i].filePath;
+                    File.Delete(tempFile);
+                }
+                OnFinsh.Invoke(dlInfo.saveFileName);
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 下载进度
+        /// </summary>
+        private void OnDownloadHandler()
+        {
+            new Action(() =>
+            {
+                long current = GetDownloadLength();
+                OnDownload.Invoke(current, dlInfo.count, dlInfo.saveFileName);
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 断开网络连接
+        /// </summary>
+        private void OnDisconnectHandler()
+        {
+            new Action(() =>
+            {
+                OnDisconnect.Invoke(dlInfo.saveFileName);
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 当前下载进度
+        /// </summary>
+        /// <returns></returns>
+        public long GetDownloadLength()
+        {
+            if (dlInfo.IsSupportMultiThreading)
+            {
+                return dls.Sum(dl => dl.GetDownloadedCount());
+            }
+            else
+            {
+                return fromIndex;
+            }
+        }
+
+        /// <summary>
+        /// 获取保存文件名
+        /// </summary>
+        /// <returns></returns>
+        public DownloadInfoModel GetFileInfo => dlInfo;
+
+    }
+}

Common/system/DownloadService.cs

@@ -0,0 +1,237 @@
+using Common.Model;
+
+using System;
+using System.IO;
+using System.Net;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 下载方法
+    /// 创建人：赵耀
+    /// 创建时间：2018年10月30日
+    /// </summary>
+    public class DownloadService
+    {
+        private string downloadUrl = "";//文件下载地址
+        private string filePath = "";//文件保存路径
+        private string method = "";//方法
+        private long fromIndex = 0;//开始下载的位置
+        private long toIndex = 0;//结束下载的位置
+        private long count = 0;//总大小
+        private long size = 524288;//每次下载大小 512kb
+        private bool isRun = false;//是否正在进行
+
+
+        public bool isFinish = false;//是否已下载完成{ get; private set; }
+
+        public bool isStopped = true;//是否已停止{ get; private set; }
+
+        /// <summary>
+        /// 开始下载
+        /// </summary>
+        public event Action OnStart;
+        /// <summary>
+        /// 下载进度
+        /// </summary>
+        public event Action OnDownload;
+        /// <summary>
+        /// 完成下载
+        /// </summary>
+        public event Action OnFinsh;
+        /// <summary>
+        /// 断开网络连接
+        /// </summary>
+        public event Action OnDisconnect;
+
+
+        public long GetDownloadedCount()
+        {
+            return count - toIndex + fromIndex - 1;
+        }
+
+        public void Stop()
+        {
+            isRun = false;
+        }
+
+        /// <summary>
+        /// 开始下载
+        /// </summary>
+        /// <param name="info"></param>
+        /// <param name="isReStart"></param>
+        /// <returns></returns>
+        public bool Start(TaskInfoModel info, bool isReStart)
+        {
+            downloadUrl = info.downloadUrl;
+            fromIndex = info.fromIndex;
+            toIndex = info.toIndex;
+            method = info.method;
+            filePath = info.filePath;
+            count = info.count;
+            isStopped = false;
+            if (File.Exists(filePath))
+            {
+                if (isReStart)
+                {
+                    File.Delete(filePath);
+                    File.Create(filePath).Close();
+                }
+            }
+            else
+            {
+                File.Create(filePath).Close();
+            }
+            using (FileStream file = File.Open(filePath, FileMode.Open))
+            {
+                fromIndex = info.fromIndex + file.Length;
+            }
+            if (fromIndex >= toIndex)
+            {
+                OnFineshHandler();
+                isFinish = true;
+                isStopped = true;
+                return false;
+            }
+            OnStartHandler();
+            isRun = true;
+            new Action(() =>
+            {
+                WebResponse rsp;
+                while (fromIndex < toIndex && isRun)
+                {
+                    long to;
+                    if (fromIndex + size >= toIndex - 1)
+                    {
+                        to = toIndex - 1;
+                    }
+                    else
+                    {
+                        to = fromIndex + size;
+                    }
+
+                    try
+                    {
+                        using (rsp = HttpHelper.Download(downloadUrl, fromIndex, to, method))
+                        {
+                            Save(filePath, rsp.GetResponseStream());
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        string ErrMessage = "【下载】(DownloadService):" + ex.Message;
+                        LogHelper.WriteErrLog(ErrMessage, ex);
+                        OnDisconnectHandler();
+                        return;
+                    }
+                }
+                if (!isRun)
+                {
+                    isStopped = true;
+                }
+
+                if (fromIndex >= toIndex)
+                {
+                    isFinish = true;
+                    isStopped = true;
+                    OnFineshHandler();
+                }
+
+            }).BeginInvoke(null, null);
+            return true;
+        }
+        /// <summary>
+        /// 保存文件
+        /// </summary>
+        /// <param name="filePath"></param>
+        /// <param name="stream"></param>
+        private void Save(string filePath, Stream stream)
+        {
+            try
+            {
+                using (FileStream writer = File.Open(filePath, FileMode.Append))
+                {
+                    using (stream)
+                    {
+                        int repeatTimes = 0;
+                        byte[] buffer = new byte[1024];
+                        int length = 0;
+                        while ((length = stream.Read(buffer, 0, buffer.Length)) > 0 && isRun)
+                        {
+                            writer.Write(buffer, 0, length);
+                            fromIndex += length;
+                            if (repeatTimes % 5 == 0)
+                            {
+                                OnDownloadHandler();
+                            }
+                            repeatTimes++;
+                        }
+                    }
+                }
+                OnDownloadHandler();
+            }
+            catch (Exception)
+            {
+                //异常也不影响
+            }
+        }
+        /// <summary>
+        /// 开始下载
+        /// </summary>
+        private void OnStartHandler()
+        {
+            new Action(() =>
+            {
+                if (OnStart != null)
+                {
+                    OnStart.Invoke();
+                }
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 完成下载
+        /// </summary>
+        private void OnFineshHandler()
+        {
+            new Action(() =>
+            {
+                if (OnFinsh != null)
+                {
+                    OnFinsh.Invoke();
+                }
+
+                if (OnDownload != null)
+                {
+                    OnDownload.Invoke();
+                }
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 下载进度
+        /// </summary>
+        private void OnDownloadHandler()
+        {
+            new Action(() =>
+            {
+                if (OnDownload != null)
+                {
+                    OnDownload.Invoke();
+                }
+            }).BeginInvoke(null, null);
+        }
+        /// <summary>
+        /// 断开网络连接
+        /// </summary>
+        private void OnDisconnectHandler()
+        {
+            new Action(() =>
+            {
+                if (OnDisconnect != null)
+                {
+                    OnDisconnect.Invoke();
+                }
+            }).BeginInvoke(null, null);
+
+        }
+    }
+}

Common/system/FileToolsCommon.cs

@@ -0,0 +1,982 @@
+using System;
+using System.Configuration;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Windows.Forms;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 文件工具公共方法
+    /// 创建人：赵耀
+    /// 创建时间：2018年11月6日
+    /// </summary>
+    public static class FileToolsCommon
+    {
+        #region 获取文件的绝对路径
+
+        /// <summary>
+        /// 获取文件的绝对路径
+        /// </summary>
+        /// <param name="Path">相对路径</param>
+        /// <returns></returns>
+        public static string GetFileAbsolutePath(string Path = "")
+        {
+            try
+            {
+                if (!string.IsNullOrWhiteSpace(Path))
+                {
+                    Path = Path.Replace("\\", "/");
+                    if (Path != "/")
+                    {
+                        if (Path.Substring(1, 1) == ":")
+                        {
+                            return Path;
+                        }
+
+                        if (Path.Substring(0, 1) != "/")
+                        {
+                            Path = "/" + Path;
+                        }
+                    }
+                }
+                string AbsolutePath = Application.StartupPath.ToString().Replace("\\", "/") + Path;
+                return AbsolutePath;
+            }
+            catch (Exception)
+            {
+                return Path;
+            }
+        }
+        /// <summary>
+        /// 获取合法路径 结尾带/
+        /// </summary>
+        /// <returns></returns>
+        public static string GetLegalPath(string FilePath)
+        {
+            FilePath = System.IO.Path.Combine(FilePath.Replace("\\", "/"));
+            FilePath += (FilePath.Substring(FilePath.Length - 1, 1) == "/" ? "" : "/");
+            return FilePath;
+        }
+        #endregion
+
+        #region 检测路径是否合法
+        /// <summary>
+        /// 检测路径是否合法
+        /// </summary>
+        /// <param name="FilePathName">绝对路径</param>
+        /// <param name="ErrMessage">返回错误</param>
+        /// <returns></returns>
+        public static bool IsLegalPath(string FilePathName, out string ErrMessage)
+        {
+            string FilePath;
+            string FileName;
+            ErrMessage = "";
+            try
+            {
+                FilePathName = GetLegalPath(FilePathName);
+                FilePath = GetDirectoryName(FilePathName);
+                FileName = GetIOFileName(FilePathName);
+            }
+            catch (Exception)
+            {
+                ErrMessage = "路径或文件名不合法！";
+                return false;
+            }
+            Regex regex = new Regex(@"^([a-zA-Z]:\\)?[^\/\:\*\?\""\<\>\|\,]*$");
+            Match m = regex.Match(FilePath);
+            if (!m.Success)
+            {
+                ErrMessage = "非法的文件保存路径！";
+                return false;
+            }
+            if (!string.IsNullOrWhiteSpace(FileName))
+            {
+                regex = new Regex(@"^[^\/\:\*\?\""\<\>\|\,]+$");
+                m = regex.Match(FileName);
+                if (!m.Success)
+                {
+                    ErrMessage = "非法的文件名！文件名中包含\\ / : * ？ \" < > |等字符!";
+                    return false;
+                }
+            }
+            return true;
+
+        }
+        #endregion
+
+        #region 检测指定目录是否存在
+        /// <summary>  
+        /// 检测指定目录是否存在  
+        /// </summary>  
+        /// <param name="directoryPath">目录的绝对路径</param>          
+        public static bool IsExistDirectory(string directoryPath)
+        {
+            return Directory.Exists(directoryPath);
+        }
+        #endregion
+
+        #region 检测指定文件是否存在
+        /// <summary>  
+        /// 检测指定文件是否存在,如果存在则返回true。  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static bool IsExistFile(string filePath)
+        {
+            return File.Exists(filePath);
+        }
+        #endregion
+
+        #region 检测指定目录是否为空
+        /// <summary>  
+        /// 检测指定目录是否为空  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>          
+        public static bool IsEmptyDirectory(string directoryPath)
+        {
+            try
+            {
+                //判断是否存在文件  
+                string[] fileNames = GetFileNames(directoryPath);
+                if (fileNames.Length > 0)
+                {
+                    return false;
+                }
+
+                //判断是否存在文件夹  
+                string[] directoryNames = GetDirectories(directoryPath);
+                return directoryNames.Length <= 0;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+        #endregion
+
+        #region 检测指定目录中是否存在指定的文件
+        /// <summary>  
+        /// 检测指定目录中是否存在指定的文件,若要搜索子目录请使用重载方法.  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>  
+        /// <param name="searchPattern">模式字符串，"*"代表0或N个字符，"?"代表1个字符。  
+        /// 范例："Log*.xml"表示搜索所有以Log开头的Xml文件。</param>          
+        public static bool Contains(string directoryPath, string searchPattern)
+        {
+            try
+            {
+                //获取指定的文件列表  
+                string[] fileNames = GetFileNames(directoryPath, searchPattern, false);
+
+                //判断指定文件是否存在  
+                return fileNames.Length != 0;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>  
+        /// 检测指定目录中是否存在指定的文件  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>  
+        /// <param name="searchPattern">模式字符串，"*"代表0或N个字符，"?"代表1个字符。  
+        /// 范例："Log*.xml"表示搜索所有以Log开头的Xml文件。</param>   
+        /// <param name="isSearchChild">是否搜索子目录</param>  
+        public static bool Contains(string directoryPath, string searchPattern, bool isSearchChild)
+        {
+            try
+            {
+                //获取指定的文件列表  
+                string[] fileNames = GetFileNames(directoryPath, searchPattern, isSearchChild);
+
+                //判断指定文件是否存在  
+                return fileNames.Length != 0;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+        #endregion
+
+        #region 创建一个目录
+        /// <summary>  
+        /// 创建一个目录  
+        /// </summary>  
+        /// <param name="directoryPath">目录的绝对路径</param>  
+        public static void CreateDirectory(string directoryPath)
+        {
+            try
+            {
+                //如果目录不存在则创建该目录  
+                if (!IsExistDirectory(directoryPath))
+                {
+                    Directory.CreateDirectory(directoryPath);
+                }
+            }
+            catch (Exception ex)
+            {
+                throw new ApplicationException(ex.Message); //"请使用管理员权限运行！"
+            }
+        }
+        #endregion
+
+        #region 创建一个文件
+        /// <summary>  
+        /// 创建一个文件。  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        public static bool CreateFile(string filePath)
+        {
+            try
+            {
+                //如果文件不存在则创建该文件  
+                if (!IsExistFile(filePath))
+                {
+                    //创建一个FileInfo对象  
+                    FileInfo file = new FileInfo(filePath);
+                    //创建文件  
+                    FileStream fs = file.Create();
+                    //关闭文件流  
+                    fs.Close();
+                }
+            }
+            catch
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>  
+        /// 创建一个文件,并将字节流写入文件。  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        /// <param name="buffer">二进制流数据</param>  
+        public static bool CreateFile(string filePath, byte[] buffer)
+        {
+            try
+            {
+                //如果文件不存在则创建该文件  
+                if (!IsExistFile(filePath))
+                {
+                    //创建一个FileInfo对象  
+                    FileInfo file = new FileInfo(filePath);
+
+                    //创建文件  
+                    FileStream fs = file.Create();
+
+                    //写入二进制流  
+                    fs.Write(buffer, 0, buffer.Length);
+
+                    //关闭文件流  
+                    fs.Close();
+                }
+            }
+            catch
+            {
+                return false;
+            }
+            return true;
+        }
+        #endregion
+
+        #region 获取文本文件的行数
+        /// <summary>  
+        /// 获取文本文件的行数  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static int GetLineCount(string filePath)
+        {
+            //将文本文件的各行读到一个字符串数组中  
+            string[] rows = File.ReadAllLines(filePath);
+
+            //返回行数  
+            return rows.Length;
+        }
+        #endregion
+
+        #region 获取一个文件的长度
+        /// <summary>  
+        /// 获取一个文件的长度,单位为Byte  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static long GetFileSize(string filePath)
+        {
+            //创建一个文件对象  
+            FileInfo fi = new FileInfo(filePath);
+
+            //获取文件的大小  
+            return fi.Length;
+        }
+
+        /// <summary>  
+        /// 获取一个文件的长度,单位为KB  
+        /// </summary>  
+        /// <param name="filePath">文件的路径</param>          
+        public static double GetFileSizeByKB(string filePath)
+        {
+            //创建一个文件对象  
+            FileInfo fi = new FileInfo(filePath);
+            //double size = fi.Length / 1024;
+            double size = Math.Round((fi.Length / 1024.0), 2, MidpointRounding.AwayFromZero);
+            //获取文件的大小  
+            return size;
+        }
+
+        /// <summary>  
+        /// 获取一个文件的长度,单位为MB  
+        /// </summary>  
+        /// <param name="filePath">文件的路径</param>          
+        public static double GetFileSizeByMB(string filePath)
+        {
+            //创建一个文件对象  
+            FileInfo fi = new FileInfo(filePath);
+            //double size = fi.Length / 1024 / 1024;
+            double size = Math.Round((fi.Length / 1024.0 / 1024.0), 2, MidpointRounding.AwayFromZero);
+            //获取文件的大小  
+            return size;
+        }
+        #endregion
+
+        #region 获取指定目录中的文件列表
+        /// <summary>  
+        /// 获取指定目录中所有文件列表  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>          
+        public static FileInfo[] GetFileInfos(string directoryPath, string files = null)
+        {
+            //如果目录不存在，则抛出异常  
+            if (!IsExistDirectory(directoryPath))
+            {
+                return null;//throw new FileNotFoundException();
+            }
+            DirectoryInfo folder = new DirectoryInfo(directoryPath);
+            FileInfo[] fileList;
+            if (files == null)
+            {
+                fileList = folder.GetFiles();
+            }
+            else
+            {
+                fileList = folder.GetFiles(files);
+            }
+            //获取文件列表  
+            return fileList;
+        }
+
+        /// <summary>  
+        /// 获取指定目录中所有文件列表  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>          
+        public static string[] GetFileNames(string directoryPath)
+        {
+            //如果目录不存在，则抛出异常  
+            if (!IsExistDirectory(directoryPath))
+            {
+                return null;//throw new FileNotFoundException();
+            }
+
+            //获取文件列表  
+            return Directory.GetFiles(directoryPath);
+        }
+
+        /// <summary>  
+        /// 获取指定目录及子目录中所有文件列表  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>  
+        /// <param name="searchPattern">模式字符串，"*"代表0或N个字符，"?"代表1个字符。  
+        /// 范例："Log*.xml"表示搜索所有以Log开头的Xml文件。</param>  
+        /// <param name="isSearchChild">是否搜索子目录</param>  
+        public static string[] GetFileNames(string directoryPath, string searchPattern, bool isSearchChild)
+        {
+            //如果目录不存在，则抛出异常  
+            if (!IsExistDirectory(directoryPath))
+            {
+                return null;//throw new FileNotFoundException();
+            }
+
+            try
+            {
+                return Directory.GetFiles(directoryPath, searchPattern, isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+        #endregion
+
+        #region 获取指定目录中的子目录列表
+        /// <summary>  
+        /// 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>          
+        public static string[] GetDirectories(string directoryPath)
+        {
+            try
+            {
+                return Directory.GetDirectories(directoryPath);
+            }
+            catch
+            {
+                return null;
+            }
+        }
+
+        /// <summary>  
+        /// 获取指定目录及子目录中所有子目录列表  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>  
+        /// <param name="searchPattern">模式字符串，"*"代表0或N个字符，"?"代表1个字符。  
+        /// 范例："Log*.xml"表示搜索所有以Log开头的Xml文件。</param>  
+        /// <param name="isSearchChild">是否搜索子目录</param>  
+        public static string[] GetDirectories(string directoryPath, string searchPattern, bool isSearchChild)
+        {
+            try
+            {
+                return Directory.GetDirectories(directoryPath, searchPattern, isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
+            }
+            catch
+            {
+                return null;//throw
+            }
+        }
+        #endregion
+
+        #region 向文本文件写入内容
+        /// <summary>  
+        /// 向文本文件中写入内容  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        /// <param name="content">写入的内容</param>          
+        public static void WriteText(string filePath, string content)
+        {
+            //向文件写入内容  
+            File.WriteAllText(filePath, content);
+        }
+        #endregion
+
+        #region 向文本文件的尾部追加内容
+        /// <summary>  
+        /// 向文本文件的尾部追加内容  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        /// <param name="content">写入的内容</param>  
+        public static void AppendText(string filePath, string content)
+        {
+            File.AppendAllText(filePath, content);
+        }
+        #endregion
+
+        #region 将现有文件的内容复制到新文件中
+        /// <summary>  
+        /// 将源文件的内容复制到目标文件中  
+        /// </summary>  
+        /// <param name="sourceFilePath">源文件的绝对路径</param>  
+        /// <param name="destFilePath">目标文件的绝对路径</param>  
+        public static void Copy(string sourceFilePath, string destFilePath)
+        {
+            File.Copy(sourceFilePath, destFilePath, true);
+        }
+        #endregion
+
+        #region 将文件移动到指定目录
+        /// <summary>  
+        /// 将文件移动到指定目录  
+        /// </summary>  
+        /// <param name="sourceFilePath">需要移动的源文件的绝对路径</param>  
+        /// <param name="descDirectoryPath">移动到的目录的绝对路径</param>  
+        public static void Move(string sourceFilePath, string descDirectoryPath)
+        {
+            //获取源文件的名称  
+            string sourceFileName = GetFileName(sourceFilePath);
+
+            if (IsExistDirectory(descDirectoryPath))
+            {
+                //如果目标中存在同名文件,则删除  
+                if (IsExistFile(descDirectoryPath + "\\" + sourceFileName))
+                {
+                    DeleteFile(descDirectoryPath + "\\" + sourceFileName);
+                }
+                //将文件移动到指定目录  
+                File.Move(sourceFilePath, descDirectoryPath + "\\" + sourceFileName);
+            }
+        }
+        #endregion
+
+        #region 将流读取到缓冲区中
+        /// <summary>  
+        /// 将流读取到缓冲区中  
+        /// </summary>  
+        /// <param name="stream">原始流</param>  
+        public static byte[] StreamToBytes(Stream stream)
+        {
+            try
+            {
+                //创建缓冲区  
+                byte[] buffer = new byte[stream.Length];
+
+                //读取流  
+                stream.Read(buffer, 0, int.Parse(stream.Length.ToString()));
+
+                //返回流  
+                return buffer;
+            }
+            catch
+            {
+                return null;
+            }
+            finally
+            {
+                //关闭流  
+                stream.Close();
+            }
+        }
+        #endregion
+
+        #region 将文件读取到缓冲区中
+        /// <summary>  
+        /// 将文件读取到缓冲区中  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        public static byte[] FileToBytes(string filePath)
+        {
+            //获取文件的大小   
+            long fileSize = GetFileSize(filePath);
+
+            //创建一个临时缓冲区  
+            byte[] buffer = new byte[fileSize];
+
+            //创建一个文件流  
+            FileInfo fi = new FileInfo(filePath);
+            FileStream fs = fi.Open(FileMode.Open);
+
+            try
+            {
+                //将文件流读入缓冲区  
+                fs.Read(buffer, 0, (int)fileSize);
+
+                return buffer;
+            }
+            catch
+            {
+                return null;
+            }
+            finally
+            {
+                //关闭文件流  
+                fs.Close();
+            }
+        }
+        /// <summary>
+        /// 读取大文件用,读取文件前面指定长度字节数
+        /// </summary>
+        /// <param name="filePath">文件路径</param>
+        /// <param name="Length">读取长度,单位字节</param>
+        /// <returns></returns>
+        public static byte[] ReadBigFile(string filePath, int Length)
+        {
+            FileStream stream = new FileStream(filePath, FileMode.Open);
+            byte[] buffer = new byte[Length];
+            //stream.Position = startIndex;
+            stream.Read(buffer, 0, Length);
+            stream.Close();
+            stream.Dispose();
+            return buffer;
+        }
+        /// <summary>
+        /// 读取指定长度的流
+        /// </summary>
+        /// <param name="filePath">文件位置</param>
+        /// <param name="startIndex">开始位置</param>
+        /// <param name="Length">长度</param>
+        /// <returns></returns>
+        public static byte[] ReadBigFileSpecifyLength(string filePath, long startIndex, int Length)
+        {
+            FileStream stream = new FileStream(filePath, FileMode.Open);
+            if (startIndex + Length + 1 > stream.Length)
+            {
+                Length = (int)(stream.Length - startIndex);
+            }
+            byte[] buffer = new byte[Length];
+            stream.Position = startIndex;
+            stream.Read(buffer, 0, Length);
+            stream.Close();
+            stream.Dispose();
+            return buffer;
+        }
+        #endregion
+
+        #region 将文件读取到字符串中
+        /// <summary>  
+        /// 将文件读取到字符串中  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        public static string FileToString(string filePath)
+        {
+            //return FileToString(filePath, Encoding.Default); 
+            return FileToString(filePath, Encoding.UTF8);
+        }
+        /// <summary>  
+        /// 将文件读取到字符串中  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        /// <param name="encoding">字符编码</param>  
+        public static string FileToString(string filePath, Encoding encoding)
+        {
+            //创建流读取器  
+            StreamReader reader = new StreamReader(filePath, encoding);
+            try
+            {
+                //读取流  
+                return reader.ReadToEnd();
+            }
+            catch
+            {
+                return string.Empty;
+            }
+            finally
+            {
+                //关闭流读取器  
+                reader.Close();
+            }
+        }
+        /// <summary>
+        /// 读取大文件用,读取文件前面指定长度字节的字符串
+        /// </summary>
+        /// <param name="filePath">文件路径</param>
+        /// <param name="Length">读取长度,单位字节</param>
+        /// <returns></returns>
+        public static string ReadBigFileStr(string filePath, int Length)
+        {
+            byte[] buffer = ReadBigFile(filePath, Length);
+            return Encoding.Default.GetString(buffer);
+        }
+
+        #endregion
+
+        #region 从文件的绝对路径中获取文件名( 包含扩展名 )
+        /// <summary>  
+        /// 从文件的绝对路径中获取文件名( 包含扩展名 )  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static string GetFileName(string filePath)
+        {
+            //获取文件的名称  
+            FileInfo fi = new FileInfo(filePath);
+            return fi.Name;
+        }
+        /// <summary>  
+        /// 使用IO从文件的绝对路径中获取文件名( 包含扩展名 )  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static string GetIOFileName(string filePath)
+        {
+            return Path.GetFileName(filePath);
+        }
+        #endregion
+
+        #region 从文件的绝对路径中获取文件名( 不包含扩展名 )
+        /// <summary>  
+        /// 从文件的绝对路径中获取文件名( 不包含扩展名 )  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static string GetFileNameNoExtension(string filePath)
+        {
+            //获取文件的名称  
+            FileInfo fi = new FileInfo(filePath);
+            return fi.Name.Split('.')[0];
+        }
+        /// <summary>  
+        /// 使用IO从文件的绝对路径中获取文件名( 不包含扩展名 )  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static string GetIOFileNameNoExtension(string filePath)
+        {
+            return System.IO.Path.GetFileNameWithoutExtension(filePath);
+        }
+        #endregion
+
+        #region 从文件的绝对路径中获取扩展名
+        /// <summary>  
+        /// 从文件的绝对路径中获取扩展名  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static string GetExtension(string filePath)
+        {
+            //获取文件的名称  
+            FileInfo fi = new FileInfo(filePath);
+            return fi.Extension;
+        }
+        /// <summary>  
+        /// 使用IO从文件的绝对路径中获取扩展名 
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static string GetIOExtension(string filePath)
+        {
+            string Extension = System.IO.Path.GetExtension(filePath);
+            return Extension;
+        }
+
+        #endregion
+
+        #region 从文件的绝对路径中获取路径名
+        /// <summary>  
+        /// 使用IO从文件的绝对路径中获取路径名  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>          
+        public static string GetDirectoryName(string filePath)
+        {
+            string DirectoryName = (System.IO.Path.GetDirectoryName(filePath) + @"/").Replace("\\", "/");
+            return DirectoryName;
+        }
+        #endregion
+
+        #region 清空指定目录
+        /// <summary>  
+        /// 清空指定目录下所有文件及子目录,但该目录依然保存.  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>  
+        public static void ClearDirectory(string directoryPath)
+        {
+            if (IsExistDirectory(directoryPath))
+            {
+                //删除目录中所有的文件  
+                string[] fileNames = GetFileNames(directoryPath);
+                foreach (string t in fileNames)
+                {
+                    DeleteFile(t);
+                }
+
+                //删除目录中所有的子目录  
+                string[] directoryNames = GetDirectories(directoryPath);
+                foreach (string t in directoryNames)
+                {
+                    DeleteDirectory(t);
+                }
+            }
+        }
+        #endregion
+
+        #region 清空文件内容
+        /// <summary>  
+        /// 清空文件内容  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        public static void ClearFile(string filePath)
+        {
+            //删除文件  
+            File.Delete(filePath);
+
+            //重新创建该文件  
+            CreateFile(filePath);
+        }
+        #endregion
+
+        #region 删除指定文件
+        /// <summary>  
+        /// 删除指定文件  
+        /// </summary>  
+        /// <param name="filePath">文件的绝对路径</param>  
+        public static void DeleteFile(string filePath)
+        {
+            try
+            {
+                if (IsExistFile(filePath))
+                {
+                    File.Delete(filePath);
+                }
+            }
+            catch (Exception)
+            {
+
+            }
+        }
+        #endregion
+
+        #region 删除指定目录
+        /// <summary>  
+        /// 删除指定目录及其所有子目录  
+        /// </summary>  
+        /// <param name="directoryPath">指定目录的绝对路径</param>  
+        public static bool DeleteDirectory(string directoryPath)
+        {
+            try
+            {
+                if (IsExistDirectory(directoryPath))
+                {
+                    Directory.Delete(directoryPath, true);
+                }
+                return true;
+            }
+            catch (Exception)
+            {
+                //目录中有文件占用
+                return false;
+            }
+        }
+        #endregion
+
+        #region 获取指定目录大小
+        /// <summary>
+        /// 获取目录大小
+        /// </summary>
+        /// <param name="directoryPath">目录地址</param>
+        /// <returns> 单位：MB</returns>
+        public static double PathSize(string directoryPath)
+        {
+            DirectoryInfo folder = new DirectoryInfo(directoryPath);
+            double DirectorySize = DirSize(folder);
+            for (int i = 0; i < 2; i++)
+            {
+                DirectorySize /= 1024;
+            }
+            return DirectorySize;
+        }
+
+        /// <summary>
+        /// 获取目录大小
+        /// </summary>
+        /// <param name="d">目录</param>
+        /// <returns>字节</returns>
+        public static long DirSize(DirectoryInfo d)
+        {
+            long Size = 0;
+            // 所有文件大小.
+            FileInfo[] fis = d.GetFiles();
+            foreach (FileInfo fi in fis)
+            {
+                Size += fi.Length;
+            }
+            // 遍历出当前目录的所有文件夹.
+            DirectoryInfo[] dis = d.GetDirectories();
+            foreach (DirectoryInfo di in dis)
+            {
+                Size += DirSize(di);   //这就用到递归了，调用父方法,注意，这里并不是直接返回值，而是调用父返回来的
+            }
+            return (Size);
+        }
+        #endregion
+
+        #region 移动目录
+        /// <summary>
+        /// 移动目录并重命名
+        /// </summary>
+        /// <param name="directoryPath">操作目录绝对路径</param>
+        /// <param name="newDirectoryPath">目标目录绝对路径</param>
+        /// <param name="Message">返回错误消息，成功则为空</param>
+        /// <returns></returns>
+        public static bool MoveDirectory(string directoryPath, string newDirectoryPath, out string Message)
+        {
+            Message = "";
+            try
+            {
+                if (!IsExistDirectory(directoryPath))//判断目录是否存在
+                {
+                    Message = "操作目录不存在！";
+                    return false;
+                }
+                if (IsExistDirectory(newDirectoryPath))
+                {
+                    Message = "目标目录已存在！";
+                    return false;
+                }
+                Directory.Move(directoryPath, newDirectoryPath);
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Message = ex.Message;
+                return false;
+            }
+        }
+        #endregion
+
+        #region 操作配置文件
+        #region 从配置文件获取Value
+        /// <summary>
+        /// 从配置文件获取Value
+        /// </summary>
+        /// <param name="key">配置文件中key字符串</param>
+        /// <returns></returns>
+        public static string GetConfigValue(string key)
+        {
+            try
+            {
+                Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
+                //获取AppSettings的节点 
+                AppSettingsSection appsection = (AppSettingsSection)config.GetSection("appSettings");
+                return appsection.Settings[key].Value;
+            }
+            catch
+            {
+                return "";
+            }
+        }
+        #endregion
+
+        #region 设置配置文件
+        /// <summary>
+        /// 设置配置文件
+        /// </summary>
+        /// <param name="key">配置文件中key字符串</param>
+        /// <param name="value">配置文件中value字符串</param>
+        /// <returns></returns>
+        public static bool SetConfigValue(string key, string value)
+        {
+            try
+            {
+                //打开配置文件 
+                Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
+                //获取AppSettings的节点 
+                AppSettingsSection appsection = (AppSettingsSection)config.GetSection("appSettings");
+                appsection.Settings[key].Value = value;
+                config.Save();
+
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+        #endregion
+        #endregion
+
+        #region 获取媒体文件的播放时长
+
+        #endregion
+
+        #region 检测是否安装了某个程序
+        /// <summary>  
+        /// 确认电脑上是否安装有某个程序 
+        /// </summary>  
+        /// <param name="softWareName">程序安装后的名称</param>
+        /// <returns>true: 有安裝, false:沒有安裝</returns>  
+        public static bool CheckSoftWartInstallState(string softWareName)
+        {
+            Microsoft.Win32.RegistryKey uninstallNode =
+                Microsoft.Win32.Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall", Microsoft.Win32.RegistryKeyPermissionCheck.ReadWriteSubTree, System.Security.AccessControl.RegistryRights.ReadKey);
+            foreach (string subKeyName in uninstallNode.GetSubKeyNames())
+            {
+                Microsoft.Win32.RegistryKey subKey = uninstallNode.OpenSubKey(subKeyName);
+                object displayName = subKey.GetValue("DisplayName");
+                if (displayName != null)
+                {
+                    if (displayName.ToString().Contains(softWareName))
+                    {
+                        return true;
+                        // MessageWindow.Show(displayName.ToString());  
+                    }
+                }
+            }
+            return false;
+        }
+        #endregion
+    }
+}

Common/system/FreeMemoryHelper.cs

@@ -0,0 +1,60 @@
+using Microsoft.Win32;
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 释放内存帮助类 创建人：赵耀 创建时间：2020年8月12日
+    /// </summary>
+    public class FreeMemoryHelper
+    {
+        [DllImport("kernel32.dll")]
+        private static extern bool SetProcessWorkingSetSize(IntPtr proc, int min, int max);
+
+        /// <summary>
+        /// Close、Hide、最小化页面时调用此方法，释放占用内存并重新分配 将暂时不需要的内容放进虚拟内存，当应用程序重新激活时，会将虚拟内存的内容重新加载到内存。
+        /// 不宜过度频繁的调用该方法，频繁调用会降低使使用性能。 创建人：赵耀 创建时间：2020年8月12日
+        /// </summary>
+        public static void ReallocateMemory()
+        {
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+
+            if (Environment.OSVersion.Platform == PlatformID.Win32NT)
+            {
+                SetProcessWorkingSetSize(System.Diagnostics.Process.GetCurrentProcess().Handle, -1, -1);
+            }
+        }
+
+        /// <summary>
+        /// ---屏蔽DevExpress试用信息 与内存释放无关
+        /// </summary>
+        public static void SetDate()
+        {
+            CreateKey();
+            RegistryKey currentUser = Registry.CurrentUser;
+            RegistryKey registryKey = currentUser.OpenSubKey("SOFTWARE\\DevExpress\\Components", writable: true);
+            registryKey.GetValue("LastAboutShowedTime");
+            string value = DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss");
+            registryKey.SetValue("LastAboutShowedTime", value);
+            currentUser.Dispose();
+        }
+
+        // 摘要: 创建键值
+        private static void CreateKey()
+        {
+            RegistryKey currentUser = Registry.CurrentUser;
+            if (currentUser.OpenSubKey("SOFTWARE\\DevExpress\\Components", writable: true) == null)
+            {
+                RegistryKey registryKey = currentUser.CreateSubKey("SOFTWARE\\DevExpress\\Components");
+                registryKey.CreateSubKey("LastAboutShowedTime").SetValue("LastAboutShowedTime", DateTime.Now.ToString("MM/dd/yyyy HH:mm:ss"));
+                registryKey.CreateSubKey("DisableSmartTag").SetValue("LastAboutShowedTime", false);
+                registryKey.CreateSubKey("SmartTagWidth").SetValue("LastAboutShowedTime", 350);
+            }
+
+            currentUser.Dispose();
+        }
+    }
+}

Common/system/HttpHelper.cs

@@ -0,0 +1,631 @@
+using Newtonsoft.Json.Linq;
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.IO;
+using System.Net;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading;
+
+namespace Common.system
+{
+    /// <summary>
+    /// HttpHelper
+    /// 创建人：赵耀
+    /// </summary>
+    public class HttpHelper
+    {
+        public static void init_Request(ref System.Net.HttpWebRequest request)
+        {
+            request.Accept = "text/json,*/*;q=0.5";
+            request.Headers.Add("Accept-Charset", "utf-8;q=0.7,*;q=0.7");
+            request.Headers.Add("Accept-Encoding", "gzip, deflate, x-gzip, identity; q=0.9");
+            request.AutomaticDecompression = System.Net.DecompressionMethods.GZip;
+            request.Timeout = 8000;
+        }
+
+        private static bool CheckValidationResult(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors)
+        {
+            return true; //总是接受  
+        }
+
+        public static System.Net.HttpWebRequest GetHttpWebRequest(string url)
+        {
+            HttpWebRequest request = null;
+            if (url.StartsWith("https", StringComparison.OrdinalIgnoreCase))
+            {
+                ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
+                request = WebRequest.Create(url) as HttpWebRequest;
+                request.ProtocolVersion = HttpVersion.Version10;
+            }
+            else
+            {
+                request = WebRequest.Create(url) as HttpWebRequest;
+            }
+            return request;
+        }
+        public static WebResponse Download(string downloadUrl, long from, long to, string method)
+        {
+            for (int i = 0; i < 10; i++)
+            {
+                try
+                {
+                    HttpWebRequest request = HttpHelper.GetHttpWebRequest(downloadUrl);
+                    HttpHelper.init_Request(ref request);
+                    request.Accept = "text/json,*/*;q=0.5";
+                    request.AddRange(from, to);
+                    request.Headers.Add("Accept-Charset", "utf-8;q=0.7,*;q=0.7");
+                    request.Headers.Add("Accept-Encoding", "gzip, deflate, x-gzip, identity; q=0.9");
+                    request.AutomaticDecompression = System.Net.DecompressionMethods.GZip;
+                    request.Timeout = 120000;
+                    request.Method = method;
+                    request.KeepAlive = false;
+                    request.ContentType = "application/json; charset=utf-8";
+                    return request.GetResponse();
+                }
+                catch (Exception)
+                {
+                    Thread.Sleep(100);
+                }
+            }
+            throw new Exception("已断开网络！请检查网络连接后重试下载！");
+        }
+        public static string Get(string url, IDictionary<string, string> param)
+        {
+            List<string> paramBuilder = new List<string>();
+            foreach (KeyValuePair<string, string> item in param)
+            {
+                paramBuilder.Add(string.Format("{0}={1}", item.Key, item.Value));
+            }
+            url = string.Format("{0}?{1}", url.TrimEnd('?'), string.Join(",", paramBuilder.ToArray()));
+            return Get(url);
+        }
+        public static string Get(string url)
+        {
+            try
+            {
+                HttpWebRequest request = GetHttpWebRequest(url);
+                if (request != null)
+                {
+                    string retval = null;
+                    init_Request(ref request);
+                    using (WebResponse Response = request.GetResponse())
+                    {
+                        using (StreamReader reader = new System.IO.StreamReader(Response.GetResponseStream(), System.Text.Encoding.UTF8))
+                        {
+                            retval = reader.ReadToEnd();
+                        }
+                    }
+                    return retval;
+                }
+            }
+            catch
+            {
+
+            }
+            return null;
+        }
+        public static string Post(string url, string data)
+        {
+            try
+            {
+                HttpWebRequest request = GetHttpWebRequest(url);
+                if (request != null)
+                {
+                    string retval = null;
+                    init_Request(ref request);
+                    request.Method = "POST";
+                    request.ServicePoint.Expect100Continue = false;
+                    request.ContentType = "application/json; charset=utf-8";
+                    request.Timeout = 5000;
+                    byte[] bytes = System.Text.UTF8Encoding.UTF8.GetBytes(data);
+                    request.ContentLength = bytes.Length;
+                    using (Stream stream = request.GetRequestStream())
+                    {
+                        stream.Write(bytes, 0, bytes.Length);
+                    }
+                    using (WebResponse response = request.GetResponse())
+                    {
+                        using (StreamReader reader = new System.IO.StreamReader(response.GetResponseStream()))
+                        {
+                            retval = reader.ReadToEnd();
+                        }
+                    }
+                    return retval;
+                }
+            }
+            catch
+            {
+
+            }
+            return null;
+        }
+
+        /// <summary>
+        ///调用Post接口
+        /// </summary>
+        /// <param name="request"></param>
+        /// <returns></returns>
+        public static string HttpPost(string body, string Url)
+        {
+            try
+            {
+                Encoding encoding = Encoding.UTF8;
+
+                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
+                request.Method = "POST";
+                request.Accept = "text/html,application/xhtml+xml,*/*";
+                request.ContentType = "application/json";
+
+                byte[] buffer = encoding.GetBytes(body);
+                request.ContentLength = buffer.Length;
+                request.GetRequestStream().Write(buffer, 0, buffer.Length);
+
+                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
+                using (StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
+                {
+                    return reader.ReadToEnd();
+                }
+            }
+            catch (Exception ex)
+            {
+                // LogHelper.Instance.Debug($"POST接口连接失败，请求参数：{ex.Message}");
+                return "POST报错:" + ex.Message;
+            }
+        }
+        /// <summary>
+        /// Post Http请求
+        /// </summary>
+        /// <param name="url">请求地址</param>
+        /// <param name="postData">传输数据</param>
+        /// <param name="timeout">超时时间</param>
+        /// <param name="contentType">媒体格式</param>
+        /// <param name="encode">编码</param>
+        /// <returns>泛型集合</returns>
+        public static T PostAndRespSignle<T>(string url, int timeout = 5000, string postData = "", string contentType = "application/json;", string encode = "UTF-8") where T : class
+        {
+            if (!string.IsNullOrEmpty(url) && !string.IsNullOrEmpty(encode) && !string.IsNullOrEmpty(contentType) && postData != null)
+            {
+                // webRequest.Headers.Add("Authorization", "Bearer " + "SportApiAuthData");
+                HttpWebResponse webResponse = null;
+                Stream responseStream = null;
+                Stream requestStream = null;
+                StreamReader streamReader = null;
+                try
+                {
+                    string respstr = GetStreamReader(url, responseStream, requestStream, streamReader, webResponse, timeout, encode, postData, contentType);
+                    return JsonHelper.JsonToObj<T>(respstr);
+                }
+                catch (Exception)
+                {
+                }
+                finally
+                {
+                    if (responseStream != null)
+                    {
+                        responseStream.Dispose();
+                    }
+
+                    if (webResponse != null)
+                    {
+                        webResponse.Close();
+                    }
+
+                    if (requestStream != null)
+                    {
+                        requestStream.Dispose();
+                    }
+
+                    if (streamReader != null)
+                    {
+                        streamReader.Dispose();
+                    }
+                }
+            }
+            return default(T);
+        }
+        private static string GetStreamReader(string url, Stream responseStream, Stream requestStream, StreamReader streamReader, WebResponse webResponse, int timeout, string encode, string postData, string contentType)
+        {
+            try
+            {
+                byte[] data = Encoding.GetEncoding(encode).GetBytes(postData);
+                HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(url);
+                webRequest.Method = "POST";
+                webRequest.ContentType = contentType + ";" + encode;
+                webRequest.ContentLength = data.Length;
+                webRequest.Timeout = timeout;
+                requestStream = webRequest.GetRequestStream();
+                requestStream.Write(data, 0, data.Length);
+                webResponse = (HttpWebResponse)webRequest.GetResponse();
+                responseStream = webResponse.GetResponseStream();
+                if (responseStream == null) { return ""; }
+                streamReader = new StreamReader(responseStream, Encoding.GetEncoding(encode));
+                return streamReader.ReadToEnd();
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+        /// <summary>
+        /// Cookie
+        /// </summary>
+        public static CookieContainer cc = new CookieContainer();
+        /// <summary>
+        /// Get请求
+        /// </summary>
+        /// <param name="serviceaddress">请求地址</param>
+        /// <param name="strcontent">头</param>
+        /// <param name="contenttype">参数</param>
+        /// <param name="header">token</param>
+        /// <returns></returns>
+        public static JObject GetFunction(string serviceaddress, string strcontent, string contenttype, string header, int Timeout = 5000)
+        {
+            try
+            {
+                string serviceAddress = serviceaddress + strcontent;
+                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(serviceAddress);
+                WebHeaderCollection myWebHeaderCollection = request.Headers;
+                request.CookieContainer = cc;
+                if (header != "")
+                {
+                    myWebHeaderCollection.Add("access_token:" + header);
+                }
+
+                request.Method = "GET";
+                request.ContentType = contenttype;
+                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
+
+                string encoding = response.ContentEncoding;
+                if (encoding == null || encoding.Length < 1)
+                {
+                    encoding = "UTF-8"; //默认编码  
+                }
+                StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(encoding));
+                string retString = reader.ReadToEnd();
+
+                //解析josn
+                JObject jo = JObject.Parse(retString);
+                return jo;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Post请求
+        /// </summary>
+        /// <param name="serviceaddress">请求地址</param>
+        /// <param name="contenttype">头 application/x-www-form-urlencoded</param>
+        /// <param name="strcontent">参数</param>
+        /// <param name="header">token</param>
+        /// <returns></returns>
+        public static JObject PostFunction(string serviceaddress, string contenttype, string strcontent, string header, int Timeout = 5000)
+        {
+            try
+            {
+                string serviceAddress = serviceaddress;
+                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(serviceAddress);
+                WebHeaderCollection myWebHeaderCollection = request.Headers;
+
+                request.CookieContainer = cc;
+                //myWebHeaderCollection.Add("Accept", "*/*");
+                if (header != "")
+                {
+                    myWebHeaderCollection.Add("access_token:" + header);
+                }
+                request.Timeout = Timeout;
+                request.Method = "POST";
+                request.ContentType = contenttype;
+
+                string strContent = strcontent;
+                using (StreamWriter dataStream = new StreamWriter(request.GetRequestStream()))
+                {
+                    dataStream.Write(strContent);
+                    dataStream.Close();
+                }
+                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
+                string encoding = response.ContentEncoding;
+                if (encoding == null || encoding.Length < 1)
+                {
+                    encoding = "UTF-8"; //默认编码  
+                }
+                StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(encoding));
+                string retString = reader.ReadToEnd();
+                retString = retString.Replace("\\r\\n", "");
+
+                //解析josn
+                JObject jo = JObject.Parse(retString);
+                return jo;
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteErrLog("请求失败（若网络无问题，请重置winsock，解决方法：以管理员方式打开cmd执行 netsh winsock reset 后重启）", ex);
+                return null;
+            }
+
+        }
+
+        /// <summary>
+        ///  上传方法
+        /// </summary>
+        /// <param name="url">webapi地址</param>
+        /// <param name="files">本地文件路径，单文件默认为string[0]</param>
+        /// <param name="token"></param>
+        /// <param name="formFields">参数可不传</param>
+        /// <returns></returns>
+        public static JObject UploadFilesToRemoteUrl(string url, string[] files, string token, NameValueCollection formFields = null)
+        {
+            string boundary = "----------------------------" + DateTime.Now.Ticks.ToString("x");
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
+            request.ContentType = "multipart/form-data; boundary=" +
+                                    boundary;
+            request.Method = "POST";
+            request.KeepAlive = true;
+
+            Stream memStream = new System.IO.MemoryStream();
+
+            byte[] boundarybytes = System.Text.Encoding.ASCII.GetBytes("\r\n--" +
+                                                                    boundary + "\r\n");
+            byte[] endBoundaryBytes = System.Text.Encoding.ASCII.GetBytes("\r\n--" +
+                                                                        boundary + "--");
+            WebHeaderCollection myWebHeaderCollection = request.Headers;
+            request.CookieContainer = cc;
+            if (token != "")
+            {
+                myWebHeaderCollection.Add("access_token:" + token);
+            }
+
+            string formdataTemplate = "\r\n--" + boundary +
+                                        "\r\nContent-Disposition: form-data; name=\"{0}\";\r\n\r\n{1}";
+            if (formFields != null)
+            {
+                foreach (string key in formFields.Keys)
+                {
+                    string formitem = string.Format(formdataTemplate, key, formFields[key]);
+                    byte[] formitembytes = System.Text.Encoding.UTF8.GetBytes(formitem);
+                    memStream.Write(formitembytes, 0, formitembytes.Length);
+                }
+            }
+
+            string headerTemplate =
+                "Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\n" +
+                "Content-Type: application/octet-stream\r\n\r\n";
+
+            for (int i = 0; i < files.Length; i++)
+            {
+                memStream.Write(boundarybytes, 0, boundarybytes.Length);
+                string header = string.Format(headerTemplate, "file", files[i]);
+                byte[] headerbytes = System.Text.Encoding.UTF8.GetBytes(header);
+
+                memStream.Write(headerbytes, 0, headerbytes.Length);
+
+                using (FileStream fileStream = new FileStream(files[i], FileMode.Open, FileAccess.Read))
+                {
+                    byte[] buffer = new byte[1024];
+                    int bytesRead = 0;
+                    while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) != 0)
+                    {
+                        memStream.Write(buffer, 0, bytesRead);
+                    }
+                }
+            }
+
+            //memStream.Write(endBoundaryBytes, 0, endBoundaryBytes.Length);
+            request.ContentLength = memStream.Length;
+
+            using (Stream requestStream = request.GetRequestStream())
+            {
+                memStream.Position = 0;
+                byte[] tempBuffer = new byte[memStream.Length];
+                memStream.Read(tempBuffer, 0, tempBuffer.Length);
+                memStream.Close();
+                requestStream.Write(tempBuffer, 0, tempBuffer.Length);
+            }
+
+            using (WebResponse response = request.GetResponse())
+            {
+                Stream stream2 = response.GetResponseStream();
+                StreamReader reader2 = new StreamReader(stream2);
+                JObject a = JObject.Parse(reader2.ReadToEnd());
+                return a;
+            }
+        }
+
+        /// <summary>
+        /// HttpWebRequest 下载
+        /// </summary>
+        /// <param name="url">URI</param>
+        /// <returns></returns>
+        public static bool GetDataGetHtml(string url, string filePath, string header)
+        {
+            try
+            {
+                HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
+
+                //httpWebRequest.ContentType = "application/x-www-form-urlencoded";
+                httpWebRequest.Method = "GET";
+                //httpWebRequest.ContentType = "image/jpeg";
+                //对发送的数据不使用缓存
+                httpWebRequest.AllowWriteStreamBuffering = false;
+                //httpWebRequest.Timeout = 300000;
+                httpWebRequest.ServicePoint.Expect100Continue = false;
+
+                WebHeaderCollection myWebHeaderCollection = httpWebRequest.Headers;
+                //myWebHeaderCollection.Add("Accept", "*/*");
+                if (header != "")
+                {
+                    myWebHeaderCollection.Add("access_token:" + header);
+                }
+
+                HttpWebResponse webRespon = (HttpWebResponse)httpWebRequest.GetResponse();
+                Stream webStream = webRespon.GetResponseStream();
+                long length = webRespon.ContentLength;
+                if (webStream == null)
+                {
+                    return false;
+                }
+                int lengthint = Convert.ToInt32(length);
+                //int num = lengthint / 1024;
+                //int count = 0;
+                //M_DownloadInfo.totalCount = lengthint / 1024;
+                //M_DownloadInfo.downloadCount = 0;
+
+                Stream stream = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
+                byte[] bArr = new byte[1024];
+                int size = webStream.Read(bArr, 0, bArr.Length);
+                while (size > 0)
+                {
+                    stream.Write(bArr, 0, size);
+                    size = webStream.Read(bArr, 0, bArr.Length);
+                    //M_DownloadInfo.downloadCount = M_DownloadInfo.downloadCount + 1;
+                }
+                webRespon.Close();
+                stream.Close();
+                webStream.Close();
+                return true;
+            }
+            catch (Exception)
+            {
+                //LogHelper.WriteErrLog("请求失败：" + ex.Message, ex);
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// 上传文件流
+        /// 创建人：赵耀
+        /// 创建时间：2020年9月5日
+        /// </summary>
+        /// <param name="url">URL</param>
+        /// <param name="databyte">文件数据流</param>
+        /// <param name="filename">文件名</param>
+        /// <param name="formFields">参数 可不传</param>
+        public static JObject UploadRequestflow(string url, byte[] databyte, string filename, NameValueCollection formFields = null)
+        {
+            JObject jobResult = null;
+            // 时间戳，用做boundary
+            string boundary = "-----" + DateTime.Now.Ticks.ToString("x");
+            byte[] boundarybytes = Encoding.ASCII.GetBytes("\r\n--" + boundary + "\r\n");
+
+            //根据uri创建HttpWebRequest对象
+            HttpWebRequest httpReq = (HttpWebRequest)WebRequest.Create(new Uri(url));
+            httpReq.ContentType = "multipart/form-data; boundary=" + boundary;
+            httpReq.Method = "POST";
+            httpReq.KeepAlive = true;
+            //httpReq.Timeout = 300000;
+            //httpReq.AllowWriteStreamBuffering = false; //对发送的数据不使用缓存
+            httpReq.Credentials = CredentialCache.DefaultCredentials;
+
+            try
+            {
+                Stream postStream = httpReq.GetRequestStream();
+                //参数
+                const string formdataTemplate = "Content-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}";
+                if (formFields != null)
+                {
+                    foreach (string key in formFields.Keys)
+                    {
+                        postStream.Write(boundarybytes, 0, boundarybytes.Length);
+                        string formitem = string.Format(formdataTemplate, key, formFields[key]);
+                        byte[] formitembytes = Encoding.UTF8.GetBytes(formitem);
+                        postStream.Write(formitembytes, 0, formitembytes.Length);
+                    }
+                }
+                postStream.Write(boundarybytes, 0, boundarybytes.Length);
+
+                const string headerTemplate = "Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\nContent-Type: application/octet-stream\r\n\r\n";
+
+                //文件头
+                string header = string.Format(headerTemplate, "file", filename);
+                byte[] headerbytes = Encoding.UTF8.GetBytes(header);
+                postStream.Write(headerbytes, 0, headerbytes.Length);
+
+                //文件流
+                postStream.Write(databyte, 0, databyte.Length);
+
+                //结束边界
+                byte[] boundaryBytes = Encoding.ASCII.GetBytes("\r\n--" + boundary + "--\r\n");
+                postStream.Write(boundaryBytes, 0, boundaryBytes.Length);
+                postStream.Close();
+
+                //获取服务器端的响应
+                using (HttpWebResponse response = (HttpWebResponse)httpReq.GetResponse())
+                {
+                    Stream receiveStream = response.GetResponseStream();
+                    StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);
+                    string returnValue = readStream.ReadToEnd();
+                    jobResult = JObject.Parse(returnValue);
+                    response.Close();
+                    readStream.Close();
+                    //MessageWindow.Show(returnValue);
+                    //LogHelper.WriteInfoLog("【文件上传】" + returnValue);
+                }
+                return jobResult;
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteErrLog("【文件上传】" + ex.Message, ex);
+                return null;
+            }
+            finally
+            {
+                httpReq = null;
+            }
+        }
+        /// <summary>
+        /// Post Http请求
+        /// </summary>
+        /// <param name="url"></param>
+        /// <param name="postData"></param>
+        /// <param name="timeout"></param>
+        /// <param name="contentType"></param>
+        /// <param name="encode"></param>
+        /// <returns>响应流字符串</returns>
+        public static string PostAndRespStr(string url, string postData = "", int timeout = 5000, string contentType = "application/json;", string encode = "UTF-8")
+        {
+            if (!string.IsNullOrEmpty(url) && !string.IsNullOrEmpty(encode) && !string.IsNullOrEmpty(contentType) && postData != null)
+            {
+                HttpWebResponse webResponse = null;
+                Stream responseStream = null;
+                Stream requestStream = null;
+                StreamReader streamReader = null;
+                try
+                {
+                    return GetStreamReader(url, responseStream, requestStream, streamReader, webResponse, timeout, encode, postData, contentType);
+                }
+                catch (Exception)
+                {
+                }
+                finally
+                {
+                    if (responseStream != null)
+                    {
+                        responseStream.Dispose();
+                    }
+
+                    if (webResponse != null)
+                    {
+                        webResponse.Close();
+                    }
+
+                    if (requestStream != null)
+                    {
+                        requestStream.Dispose();
+                    }
+
+                    if (streamReader != null)
+                    {
+                        streamReader.Dispose();
+                    }
+                }
+            }
+            return null;
+        }
+    }
+}

Common/system/ImageHelper.cs

@@ -0,0 +1,967 @@
+using System;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 图片帮助类
+    /// 创建人：赵耀
+    /// 创建时间：2018年11月1日
+    /// </summary>
+    public class ImageHelper
+    {
+        /// <summary>
+        /// 通过FileStream 来打开文件，这样就可以实现不锁定Image文件，到时可以让多用户同时访问Image文件
+        /// </summary>
+        /// <param name="path">图片位置</param>
+        /// <returns></returns>
+        public static Bitmap ReadBitmapFile(string path)
+        {
+            try
+            {
+                if (File.Exists(path))
+                {
+                    FileStream fs = File.OpenRead(path); //OpenRead
+                    int filelength = 0;
+                    filelength = (int)fs.Length; //获得文件长度 
+                    byte[] image = new byte[filelength]; //建立一个字节数组 
+                    fs.Read(image, 0, filelength); //按字节流读取 
+                    System.Drawing.Image result = System.Drawing.Image.FromStream(fs);
+                    fs.Close();
+                    Bitmap bit = new Bitmap(result);
+                    return bit;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+        /// <summary>
+        /// 通过FileStream 来打开文件，这样就可以实现不锁定Image文件，到时可以让多用户同时访问Image文件
+        /// </summary>
+        /// <param name="path">图片位置</param>
+        /// <returns></returns>
+        public static Image ReadImageFile(string path)
+        {
+            try
+            {
+                if (File.Exists(path))
+                {
+                    FileStream fs = File.OpenRead(path); //OpenRead
+                    int filelength = 0;
+                    filelength = (int)fs.Length; //获得文件长度 
+                    byte[] image = new byte[filelength]; //建立一个字节数组 
+                    fs.Read(image, 0, filelength); //按字节流读取 
+                    System.Drawing.Image result = System.Drawing.Image.FromStream(fs);
+                    fs.Close();
+                    return result;
+                }
+                else
+                {
+                    return null;
+                }
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+        #region 截屏指定UI控件
+        /// <summary>
+        /// 保存图片
+        /// </summary>
+        /// <param name="ui">需要截图的UI控件</param>
+        /// <param name="filePathName">图片保存地址 命名 1.png</param>
+        /// <param name="width">保存宽</param>
+        /// <param name="height">保存高</param>
+        public static void SaveUIToImage(FrameworkElement ui, string filePathName, int width, int height)
+        {
+            try
+            {
+                System.IO.FileStream fs = new System.IO.FileStream(filePathName, System.IO.FileMode.Create);
+                //在位图中呈现UI元素
+                RenderTargetBitmap bmp = new RenderTargetBitmap(width, height, 96d, 96d,
+                System.Windows.Media.PixelFormats.Pbgra32);
+                bmp.Render(ui);
+                BitmapEncoder encoder = new PngBitmapEncoder();
+                encoder.Frames.Add(BitmapFrame.Create(bmp));
+                encoder.Save(fs);
+                fs.Close();
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteErrLog("【UI生成图片】（SaveUIToImage）" + ex.Message, ex);
+                //Console.WriteLine(ex.Message);
+            }
+        }
+        #endregion
+        /// <summary>
+        /// 通过FileStream 来打开文件，这样就可以实现不锁定Image文件，到时可以让多用户同时访问Image文件
+        /// </summary>
+        /// <param name="path">图片位置</param>
+        /// <returns></returns>
+        public static BitmapImage ReadBitmapImageFile(string path)
+        {
+            BitmapImage bitmap = new BitmapImage();
+            try
+            {
+                using (MemoryStream ms = new MemoryStream(File.ReadAllBytes(path)))
+                {
+                    bitmap = new BitmapImage
+                    {
+                        DecodePixelHeight = 100
+                    };
+                    bitmap.BeginInit();
+                    bitmap.CacheOption = BitmapCacheOption.OnLoad;//设置缓存模式
+                    bitmap.StreamSource = ms;//通过StreamSource加载图片
+                    bitmap.EndInit();
+                    bitmap.Freeze();
+                }
+                return bitmap;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+        #region 获取RGB
+
+        private static Bitmap _Bitmap = null;
+        private static StringBuilder sb = new StringBuilder();
+
+        public static string GetRGB(int x, int y)
+        {
+            sb = new StringBuilder();
+            try
+            {
+                System.Drawing.Color color = _Bitmap.GetPixel(x, y);
+
+                sb.Append("RGB:（");
+                sb.Append(color.R.ToString());
+                sb.Append(",");
+                sb.Append(color.G.ToString());
+                sb.Append(",");
+                sb.Append(color.B.ToString());
+                sb.Append("）");
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteErrLog("ImageHelper(GetRGB)" + ex.Message, ex);
+            }
+
+            return sb.ToString();
+        }
+
+        #endregion 获取RGB
+
+        #region 截图统一方法
+        /// <summary>
+        /// 截图通用方法 创建人：赵耀 创建时间：2020年8月11日
+        /// </summary>
+        /// <param name="ScreenSize">截图的区域，设置new Rectangle(0, 0, 0, 0)为截全屏</param>
+        /// <param name="ImageSavePath">图片存储路径，为空或null则保存到临时文件夹</param>
+        /// <param name="IsRetImg">是否返回图片</param>
+        /// <param name="bitmapimg">图片</param>
+        /// <param name="level">压缩等级，0到100，0 最差质量，100 最佳</param>
+        /// <returns></returns>
+        public static bool GetScreenshot(Rectangle ScreenSize, string ImageSavePath, bool IsRetImg, out BitmapImage bitmapimg, long level = -1)
+        {
+            bitmapimg = null;
+            try
+            {
+                System.Drawing.Size bounds = PrimaryScreen.DESKTOP;
+                if (string.IsNullOrEmpty(ImageSavePath))
+                {
+                    ImageSavePath = GetTempImagePath();//如果为空则指定临时存储路径
+                }
+                double scaleWidth = (bounds.Width * 1.0) / SystemParameters.PrimaryScreenWidth;
+                double scaleHeight = (bounds.Height * 1.0) / SystemParameters.PrimaryScreenHeight;
+                int width = bounds.Width;
+                int height = bounds.Height;
+                if (ScreenSize.Size != new System.Drawing.Size(0, 0))
+                {
+                    width = (int)(ScreenSize.Size.Width * scaleWidth);
+                    height = (int)(ScreenSize.Size.Height * scaleHeight);
+                }
+                int l = (int)(ScreenSize.X * scaleWidth);
+                int t = (int)(ScreenSize.Y * scaleHeight);
+                if (_Bitmap != null)
+                {
+                    _Bitmap.Dispose();
+                }
+                _Bitmap = new Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
+                using (Graphics g = Graphics.FromImage(_Bitmap))
+                {
+                    g.CopyFromScreen(l, t, 0, 0, _Bitmap.Size, CopyPixelOperation.SourceCopy);
+                    Compress(_Bitmap, ImageSavePath, level);
+                }
+                if (IsRetImg)
+                {
+
+                    Uri uri = new Uri(ImageSavePath, UriKind.Absolute);
+                    bitmapimg = new BitmapImage(uri);
+                }
+                GC.Collect();
+                return true;
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteErrLog("【截图】(GetBitmapSource)截图失败，" + ex.Message, ex);
+                return false;
+            }
+        }
+        /// <summary>
+        /// 获取临时图片保存位置
+        /// </summary>
+        /// <returns></returns>
+        public static string GetTempImagePath()
+        {
+            TimeSpan ts = DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0);
+
+            string TempPath = FileToolsCommon.GetFileAbsolutePath("/temp/Screenshot/");
+            FileToolsCommon.CreateDirectory(TempPath);
+            TempPath += Convert.ToInt64(ts.TotalMilliseconds).ToString() + ".jpg";
+            return TempPath;
+        }
+        #endregion 截图统一方法
+
+        #region 图片压缩
+
+        /// <summary>
+        /// 图片压缩(降低质量以减小文件的大小) 创建人：赵耀 创建时间：2020年8月11日
+        /// </summary>
+        /// <param name="srcBitMap">传入的Bitmap对象</param>
+        /// <param name="destFile">压缩后的图片保存路径</param>
+        /// <param name="level">压缩等级，-1为config配置的值，0到100，0 最差质量，100 最佳</param>
+        public static void Compress(Bitmap srcBitMap, string destFile, long level)
+        {
+            if (level <= -1)
+            {
+                int ImageCompressionLevel = int.Parse(FileToolsCommon.GetConfigValue("ImageCompressionLevel"));
+                level = ImageCompressionLevel;
+            }
+            Stream s = new FileStream(destFile, FileMode.Create);
+            Compress(srcBitMap, s, level);
+            s.Close();
+        }
+
+        /// <summary>
+        /// 图片压缩(降低质量以减小文件的大小) 创建人：赵耀 创建时间：2020年8月11日
+        /// </summary>
+        /// <param name="srcBitmap">传入的Bitmap对象</param>
+        /// <param name="destStream">压缩后的Stream对象</param>
+        /// <param name="level">压缩等级，0到100，0 最差质量，100 最佳</param>
+        public static void Compress(Bitmap srcBitmap, Stream destStream, long level)
+        {
+            ImageCodecInfo myImageCodecInfo;
+            System.Drawing.Imaging.Encoder myEncoder;
+            EncoderParameter myEncoderParameter;
+            EncoderParameters myEncoderParameters;
+
+            //获取表示jpeg编解码器的imagecodecinfo对象
+            myImageCodecInfo = GetEncoderInfo("image/jpeg");
+
+            myEncoder = System.Drawing.Imaging.Encoder.Quality;
+
+            myEncoderParameters = new EncoderParameters(1);
+
+            myEncoderParameter = new EncoderParameter(myEncoder, level);
+            myEncoderParameters.Param[0] = myEncoderParameter;
+            srcBitmap.Save(destStream, myImageCodecInfo, myEncoderParameters);
+        }
+
+        /// <summary>
+        /// 获取解码器 创建人：赵耀 创建时间2020年8月11日
+        /// </summary>
+        /// <param name="mimeType"></param>
+        /// <returns></returns>
+        private static ImageCodecInfo GetEncoderInfo(string mimeType)
+        {
+            int j;
+            ImageCodecInfo[] encoders;
+            encoders = ImageCodecInfo.GetImageEncoders();
+            for (j = 0; j < encoders.Length; ++j)
+            {
+                if (encoders[j].MimeType == mimeType)
+                {
+                    return encoders[j];
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// 压缩图片 -测试方法 待完善 暂无用
+        /// </summary>
+        /// <param name="_bitmap">原图片</param>
+        /// <param name="dFile">压缩后保存图片地址</param>
+        /// <param name="flag">压缩质量（数字越小压缩率越高）1-100</param>
+        /// <param name="size">压缩后图片的最大大小</param>
+        /// <param name="sfsc">是否是第一次调用</param>
+        /// <returns></returns>
+        public static bool CompressImage(Bitmap _bitmap, string dFile, int flag = 90, int size = 300)
+        {
+            ////如果是第一次调用，原始图像的大小小于要压缩的大小，则直接复制文件，并且返回true
+            //FileInfo firstFileInfo = new FileInfo(sFile);
+            //if (sfsc == true && firstFileInfo.Length < size * 1024)
+            //{
+            //    firstFileInfo.CopyTo(dFile);
+            //    return true;
+            //}
+            //Image iSource = Image.FromFile(sFile);
+            Image iSource = _bitmap;
+            ImageFormat tFormat = iSource.RawFormat;
+            int dHeight = iSource.Height / 2;
+            int dWidth = iSource.Width / 2;
+            int sW, sH;
+            //按比例缩放
+            System.Drawing.Size tem_size = new System.Drawing.Size(iSource.Width, iSource.Height);
+            if (tem_size.Width > dHeight || tem_size.Width > dWidth)
+            {
+                if ((tem_size.Width * dHeight) > (tem_size.Width * dWidth))
+                {
+                    sW = dWidth;
+                    sH = (dWidth * tem_size.Height) / tem_size.Width;
+                }
+                else
+                {
+                    sH = dHeight;
+                    sW = (tem_size.Width * dHeight) / tem_size.Height;
+                }
+            }
+            else
+            {
+                sW = tem_size.Width;
+                sH = tem_size.Height;
+            }
+
+            Bitmap ob = new Bitmap(dWidth, dHeight);
+            Graphics g = Graphics.FromImage(ob);
+
+            g.Clear(System.Drawing.Color.WhiteSmoke);
+            g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
+            g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
+            g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
+
+            g.DrawImage(iSource, new Rectangle((dWidth - sW) / 2, (dHeight - sH) / 2, sW, sH), 0, 0, iSource.Width, iSource.Height, GraphicsUnit.Pixel);
+
+            g.Dispose();
+
+            //以下代码为保存图片时，设置压缩质量
+            EncoderParameters ep = new EncoderParameters();
+            long[] qy = new long[1];
+            qy[0] = flag;//设置压缩的比例1-100
+            EncoderParameter eParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, qy);
+            ep.Param[0] = eParam;
+
+            try
+            {
+                ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
+                ImageCodecInfo jpegICIinfo = null;
+                for (int x = 0; x < arrayICI.Length; x++)
+                {
+                    if (arrayICI[x].FormatDescription.Equals("JPEG"))
+                    {
+                        jpegICIinfo = arrayICI[x];
+                        break;
+                    }
+                }
+                if (jpegICIinfo != null)
+                {
+                    if (flag > 0)
+                    {
+                        ob.Save(dFile, jpegICIinfo, ep);//dFile是压缩后的新路径
+                        FileInfo fi = new FileInfo(dFile);
+                        if (fi.Length > 1024 * size)
+                        {
+                            flag -= 10;
+                            CompressImage(_bitmap, dFile, flag, size);
+                        }
+                    }
+                    //ob.Save(dFile, jpegICIinfo, ep);
+                    //FileInfo fi = new FileInfo(dFile);
+                    //bool IsAgain = false;
+                    //if (fi.Length > 1024 * size)
+                    //{
+                    //    fi.CopyTo(dFile + fi.Length);
+                    //    fi.Delete();
+                    //    Bitmap newbitmap = ReadImageFile(dFile + fi.Length);
+                    //    CompressImage(newbitmap, dFile, flag, size);
+                    //    FileToolsCommon.DeleteFile(dFile + fi.Length);
+                    //}
+                }
+                else
+                {
+                    ob.Save(dFile, tFormat);
+                }
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+            finally
+            {
+                iSource.Dispose();
+                ob.Dispose();
+            }
+        }
+        #endregion 图片压缩
+
+        #region 截屏指定UI控件
+        /// <summary>
+        /// 保存图片
+        /// </summary>
+        /// <param name="ui">需要截图的UI控件</param>
+        /// <param name="filePathName">图片保存地址 命名 1.png</param>
+        /// <param name="width">图片宽</param>
+        /// <param name="height">图片高</param>
+        /// <param name="ImgWidth">转换后高</param>
+        /// <param name="ImgHeight">转换后高</param>
+        public static void SaveUI(FrameworkElement ui, string filePathName, int width, int height, int ImgWidth, int ImgHeight)
+        {
+            try
+            {
+                //在位图中呈现UI元素
+                RenderTargetBitmap bmp = new RenderTargetBitmap(width, height, PrimaryScreen.DpiX, PrimaryScreen.DpiY, PixelFormats.Pbgra32);
+                bmp.Render(ui);
+
+                //定义切割矩形
+                var cut = new Int32Rect(0, 0, width, height);
+                //计算Stride
+                var stride = bmp.Format.BitsPerPixel * cut.Width / 8;
+                //声明字节数组
+                byte[] data = new byte[cut.Height * stride];
+
+                //调用CopyPixels
+                bmp.CopyPixels(cut, data, stride, 0);
+                new Thread(new ThreadStart(new Action(() =>
+                {
+                    BitmapSource bitmapSource = BitmapSource.Create(width, height, PrimaryScreen.DpiX, PrimaryScreen.DpiY, PixelFormats.Bgr32, null, data, stride);
+
+                    BitmapEncoder encoder = new PngBitmapEncoder();
+                    encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
+                    if (ImgWidth > 0)
+                    {
+                        Bitmap Img = new Bitmap(ImgWidth, ImgHeight);
+                        try
+                        {
+                            //MemoryStream memoryStream = new MemoryStream(data);
+                            //Bitmap bit = (Bitmap)Image.FromStream(memoryStream);
+
+                            MemoryStream memoryStream = new MemoryStream();
+                            encoder.Save(memoryStream);
+                            Bitmap bit = new Bitmap(memoryStream, true);
+                            if (ImgWidth - 2 < bit.Width)
+                            {
+                                try
+                                {
+                                    Graphics g = Graphics.FromImage(Img);
+                                    g.DrawImage(bit, new Rectangle(0, 0, ImgWidth, ImgHeight), new Rectangle(0, 0, bit.Width, bit.Height), GraphicsUnit.Pixel);
+                                    g.Dispose();
+                                }
+                                catch
+                                {
+                                    Img = bit;
+                                }
+                            }
+                            else
+                            {
+                                Img = bit;
+                            }
+                            Img.Save(filePathName);
+                            memoryStream.Dispose();
+                            Img.Dispose();
+                            bit.Dispose();
+                        }
+                        catch (Exception)
+                        {
+                            using (var stream = new FileStream(filePathName, FileMode.Create))
+                            {
+                                encoder.Save(stream);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        using (var stream = new FileStream(filePathName, FileMode.Create))
+                        {
+                            encoder.Save(stream);
+                        }
+                    }
+                }))).Start();
+            }
+            catch (Exception)
+            {
+
+            }
+        }
+
+        /// <summary>
+        /// 保存图片
+        /// </summary>
+        /// <param name="ui">需要截图的UI控件</param>
+        /// <param name="filePathName">图片保存地址 命名 1.png</param>
+        /// <param name="width">窗口宽</param>
+        /// <param name="height">窗口高</param>
+        /// <param name="ImgWidth">图片高</param>
+        /// <param name="ImgHeight">图片高</param>
+        public static void SaveUIToImage(FrameworkElement ui, string filePathName, int width, int height, int ImgWidth, int ImgHeight)
+        {
+            try
+            {
+                //在位图中呈现UI元素
+                RenderTargetBitmap bmp = new RenderTargetBitmap(width, height, PrimaryScreen.DpiX, PrimaryScreen.DpiY, PixelFormats.Pbgra32);
+                bmp.Render(ui);
+                BitmapEncoder encoder = new PngBitmapEncoder();
+                encoder.Frames.Add(BitmapFrame.Create(bmp));
+                if (ImgWidth > 0)
+                {
+                    Bitmap Img = new Bitmap(ImgWidth, ImgHeight);
+                    try
+                    {
+                        MemoryStream memoryStream = new MemoryStream();
+                        encoder.Save(memoryStream);
+                        new Thread(new ThreadStart(new Action(() =>
+                        {
+                            //System.Drawing.Image img = System.Drawing.Image.FromStream(memoryStream);
+                            Bitmap bit = new Bitmap(memoryStream);
+                            if (ImgWidth - 2 < bit.Width)
+                            {
+                                try
+                                {
+                                    Graphics g = Graphics.FromImage(Img);
+                                    //g.InterpolationMode = InterpolationMode.HighQualityBicubic;
+                                    g.DrawImage(bit, new Rectangle(0, 0, ImgWidth, ImgHeight), new Rectangle(0, 0, bit.Width, bit.Height), GraphicsUnit.Pixel);
+                                    g.Dispose();
+                                }
+                                catch
+                                {
+                                    Img = bit;
+                                }
+                            }
+                            else
+                            {
+                                Img = bit;
+                            }
+                            Img.Save(filePathName);
+                            //Bitmap bitmap = CutImageWhitePart(Img);
+                            //FileToolsCommon.DeleteFile(filePathName);
+                            //bitmap.Save(filePathName);
+                            //bitmap.Dispose();
+                            memoryStream.Dispose();
+                            Img.Dispose();
+                            bit.Dispose();
+                        }))).Start();
+                    }
+                    catch (Exception)
+                    {
+
+                    }
+                }
+                else
+                {
+                    //SaveImageModel sim = new SaveImageModel();
+                    //sim.encoder = new PngBitmapEncoder();
+                    //sim.encoder = new PngBitmapEncoder();
+                    //BitmapFrame test= encoder.Frames[0];
+                    //sim.encoder.Frames.Add(BitmapFrame.Create(test));
+                    ////sim.encoder.Frames[0].CopyTo(encoder.Frames[0]);
+                    ////sim.encoder.CopyTo(encoder);
+                    ////encoder.CopyTo(sim.encoder);
+                    //sim.FilePath = filePathName;
+                    ////sim.bmp = new RenderTargetBitmap(width, height, PrimaryScreen.DpiX, PrimaryScreen.DpiY, PixelFormats.Pbgra32);
+                    ////bmp.CopyTo(sim.bmp);
+                    //Thread t1 = new Thread(SaveImage);
+                    //t1.Start(sim);
+
+                    System.IO.FileStream fs = new System.IO.FileStream(filePathName, System.IO.FileMode.Create);
+                    encoder.Save(fs);
+                    fs.Close();
+                }
+            }
+            catch (Exception ex)
+            {
+                LogHelper.WriteErrLog("【UI生成图片】（SaveUIToImage）" + ex.Message, ex);
+                //Console.WriteLine(ex.Message);
+            }
+        }
+        public static void SaveUI1(FrameworkElement ui, string filePathName, int width, int height, int ImgWidth, int ImgHeight)
+        {
+            try
+            {
+                //在位图中呈现UI元素
+                RenderTargetBitmap bmp = new RenderTargetBitmap(width, height, PrimaryScreen.DpiX, PrimaryScreen.DpiY, PixelFormats.Pbgra32);
+                bmp.Render(ui);
+
+                //BitmapEncoder encoder = new PngBitmapEncoder();
+                //encoder.Frames.Add(BitmapFrame.Create(bmp));
+
+                //BitmapSource bitmapSource= bmp.Clone();
+
+
+
+                //定义切割矩形
+                var cut = new Int32Rect(0, 0, width, height);
+                //计算Stride
+                var stride = bmp.Format.BitsPerPixel * cut.Width / 8;
+                //声明字节数组
+                byte[] data = new byte[cut.Height * stride];
+
+                //调用CopyPixels
+                bmp.CopyPixels(cut, data, stride, 0);
+                new Thread(new ThreadStart(new Action(() =>
+                {
+                    BitmapSource bitmapSource = BitmapSource.Create(width, height, PrimaryScreen.DpiX, PrimaryScreen.DpiY, PixelFormats.Bgr32, null, data, stride);
+
+                    BitmapEncoder encoder = new PngBitmapEncoder();
+                    encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
+
+                    using (var stream = new FileStream(filePathName, FileMode.Create))
+                    {
+                        encoder.Save(stream);
+                    }
+                }))).Start();
+                //SaveModel saveModel = new SaveModel();
+                //saveModel.ImgWidth = ImgWidth;
+                //saveModel.ImgHeight = ImgHeight;
+                //saveModel.filePathName = filePathName;
+                //saveModel.bmp = bmp;
+                //saveModel.encoder =new PngBitmapEncoder();
+                //foreach (BitmapFrame eitem in encoder.Frames)
+                //{
+                //    saveModel.encoder = new PngBitmapEncoder();
+                //    saveModel.encoder.Frames.Add( eitem );
+                //}
+
+                //Thread myThread = new Thread(SaveImage);
+                //myThread.Start(saveModel);
+            }
+            catch (Exception)
+            {
+
+            }
+
+        }
+        public static void SaveImage(object model)
+        {
+            try
+            {
+                SaveModel saveModel = (SaveModel)model;
+                int ImgWidth = saveModel.ImgWidth;
+                int ImgHeight = saveModel.ImgHeight;
+                //BitmapEncoder encoder = saveModel.encoder;
+                RenderTargetBitmap bmp = saveModel.bmp;
+                BitmapEncoder encoder = new PngBitmapEncoder();
+                encoder.Frames.Add(BitmapFrame.Create(bmp));
+                string filePathName = saveModel.filePathName;
+                if (ImgWidth > 0)
+                {
+                    Bitmap Img = new Bitmap(ImgWidth, ImgHeight);
+                    try
+                    {
+                        MemoryStream memoryStream = new MemoryStream();
+                        encoder.Save(memoryStream);
+                        new Thread(new ThreadStart(new Action(() =>
+                        {
+                        //System.Drawing.Image img = System.Drawing.Image.FromStream(memoryStream);
+                        Bitmap bit = new Bitmap(memoryStream);
+                            if (ImgWidth - 2 < bit.Width)
+                            {
+                                try
+                                {
+                                    Graphics g = Graphics.FromImage(Img);
+                                //g.InterpolationMode = InterpolationMode.HighQualityBicubic;
+                                g.DrawImage(bit, new Rectangle(0, 0, ImgWidth, ImgHeight), new Rectangle(0, 0, bit.Width, bit.Height), GraphicsUnit.Pixel);
+                                    g.Dispose();
+                                }
+                                catch
+                                {
+                                    Img = bit;
+                                }
+                            }
+                            else
+                            {
+                                Img = bit;
+                            }
+                            Img.Save(filePathName);
+                        //Bitmap bitmap = CutImageWhitePart(Img);
+                        //FileToolsCommon.DeleteFile(filePathName);
+                        //bitmap.Save(filePathName);
+                        //bitmap.Dispose();
+                        memoryStream.Dispose();
+                            Img.Dispose();
+                            bit.Dispose();
+                        }))).Start();
+                    }
+                    catch (Exception)
+                    {
+
+                    }
+                }
+                else
+                {
+                    //SaveImageModel sim = new SaveImageModel();
+                    //sim.encoder = new PngBitmapEncoder();
+                    //sim.encoder = new PngBitmapEncoder();
+                    //BitmapFrame test= encoder.Frames[0];
+                    //sim.encoder.Frames.Add(BitmapFrame.Create(test));
+                    ////sim.encoder.Frames[0].CopyTo(encoder.Frames[0]);
+                    ////sim.encoder.CopyTo(encoder);
+                    ////encoder.CopyTo(sim.encoder);
+                    //sim.FilePath = filePathName;
+                    ////sim.bmp = new RenderTargetBitmap(width, height, PrimaryScreen.DpiX, PrimaryScreen.DpiY, PixelFormats.Pbgra32);
+                    ////bmp.CopyTo(sim.bmp);
+                    //Thread t1 = new Thread(SaveImage);
+                    //t1.Start(sim);
+
+                    System.IO.FileStream fs = new System.IO.FileStream(filePathName, System.IO.FileMode.Create);
+                    encoder.Save(fs);
+                    fs.Close();
+                }
+            }
+            catch (Exception)
+            {
+
+            }
+        }
+        /// <summary>
+        /// 截图转换成bitmap
+        /// </summary>
+        /// <param name="element"></param>
+        /// <param name="width">默认控件宽度</param>
+        /// <param name="height">默认控件高度</param>
+        /// <param name="x">默认0</param>
+        /// <param name="y">默认0</param>
+        /// <returns></returns>
+        public static Bitmap ToBitmap(FrameworkElement element, string filePathName, int width = 0, int height = 0, int x = 0, int y = 0)
+        {
+            if (width == 0) width = (int)element.ActualWidth;
+            if (height == 0) height = (int)element.ActualHeight;
+
+            var rtb = new RenderTargetBitmap(width, height, x, y, System.Windows.Media.PixelFormats.Default);
+            rtb.Render(element);
+            var bit = BitmapSourceToBitmap(rtb);
+
+            //测试代码
+            DirectoryInfo d = new DirectoryInfo(System.IO.Path.Combine(Directory.GetCurrentDirectory(), "Cache"));
+            if (!d.Exists) d.Create();
+            bit.Save(System.IO.Path.Combine(d.FullName, "控件截图.png"));
+
+            return bit;
+        }
+
+        /// <summary>
+        /// BitmapSource转Bitmap
+        /// </summary>
+        /// <param name="source"></param>
+        /// <returns></returns>
+        public static Bitmap BitmapSourceToBitmap(BitmapSource source)
+        {
+            return BitmapSourceToBitmap(source, source.PixelWidth, source.PixelHeight);
+        }
+
+        /// <summary>
+        /// Convert BitmapSource to Bitmap
+        /// </summary>
+        /// <param name="source"></param>
+        /// <returns></returns>
+        public static Bitmap BitmapSourceToBitmap(BitmapSource source, int width, int height)
+        {
+            Bitmap bmp = null;
+            try
+            {
+                System.Drawing.Imaging.PixelFormat format = System.Drawing.Imaging.PixelFormat.Format24bppRgb;
+                /*set the translate type according to the in param(source)*/
+                switch (source.Format.ToString())
+                {
+                    case "Rgb24":
+                    case "Bgr24": format = System.Drawing.Imaging.PixelFormat.Format24bppRgb; break;
+                    case "Bgra32": format = System.Drawing.Imaging.PixelFormat.Format32bppPArgb; break;
+                    case "Bgr32": format = System.Drawing.Imaging.PixelFormat.Format32bppRgb; break;
+                    case "Pbgra32": format = System.Drawing.Imaging.PixelFormat.Format32bppArgb; break;
+                }
+                bmp = new Bitmap(width, height, format);
+                BitmapData data = bmp.LockBits(new System.Drawing.Rectangle(System.Drawing.Point.Empty, bmp.Size),
+                    ImageLockMode.WriteOnly,
+                    format);
+                source.CopyPixels(Int32Rect.Empty, data.Scan0, data.Height * data.Stride, data.Stride);
+                bmp.UnlockBits(data);
+            }
+            catch
+            {
+                if (bmp != null)
+                {
+                    bmp.Dispose();
+                    bmp = null;
+                }
+            }
+
+            return bmp;
+        }
+        private static void SaveImage1(object obj)
+        {
+            SaveImageModel sim = (SaveImageModel)obj;
+            //RenderTargetBitmap bmp = sim.bmp;
+            //BitmapEncoder encoder = new PngBitmapEncoder();
+            //encoder.Frames.Add(BitmapFrame.Create(bmp));
+            BitmapEncoder encoder = sim.encoder;
+            string filePathName = sim.FilePath;
+            System.IO.FileStream fs = new System.IO.FileStream(filePathName, System.IO.FileMode.Create);
+            encoder.Save(fs);
+            fs.Close();
+        }
+
+        #endregion
+
+        #region 去掉白边
+        /// <summary>
+        /// 裁剪图片（去掉白边）
+        /// </summary>
+        /// <param name="FilePath"></param>
+        public static Bitmap CutImageWhitePart(Bitmap bmp)
+        {
+            //Bitmap bmp = new Bitmap(FilePath);
+            //上左右下
+            int top = 0, left = 0, right = bmp.Width, bottom = bmp.Height;
+
+            //寻找最上面的标线,从左(0)到右，从上(0)到下
+            for (int i = 0; i < bmp.Height; i++)//行
+            {
+                bool find = false;
+                for (int j = 0; j < bmp.Width; j++)//列
+                {
+                    System.Drawing.Color c = bmp.GetPixel(j, i);
+                    if (!IsWhite(c))
+                    {
+                        top = i;
+                        find = true;
+                        break;
+                    }
+                }
+                if (find)
+                {
+                    break;
+                }
+            }
+            //寻找最左边的标线，从上（top位）到下，从左到右
+            for (int i = 0; i < bmp.Width; i++)//列
+            {
+                bool find = false;
+                for (int j = top; j < bmp.Height; j++)//行
+                {
+                    System.Drawing.Color c = bmp.GetPixel(i, j);
+                    if (!IsWhite(c))
+                    {
+                        left = i;
+                        find = true;
+                        break;
+                    }
+                }
+                if (find)
+                {
+                    break;
+                }
+            }
+            //寻找最下边标线，从下到上，从左到右
+            for (int i = bmp.Height - 1; i >= 0; i--)//行
+            {
+                bool find = false;
+                for (int j = left; j < bmp.Width; j++)//列
+                {
+                    System.Drawing.Color c = bmp.GetPixel(j, i);
+                    if (!IsWhite(c))
+                    {
+                        bottom = i;
+                        find = true;
+                        break;
+                    }
+                }
+                if (find)
+                {
+                    break;
+                }
+            }
+            //寻找最右边的标线，从上到下，从右往左
+            for (int i = bmp.Width - 1; i >= 0; i--)//列
+            {
+                bool find = false;
+                for (int j = 0; j <= bottom; j++)//行
+                {
+                    System.Drawing.Color c = bmp.GetPixel(i, j);
+                    if (!IsWhite(c))
+                    {
+                        right = i;
+                        find = true;
+                        break;
+                    }
+                }
+                if (find)
+                {
+                    break;
+                }
+            }
+
+            if (right - left <= 0)//zxyceshi
+            {
+                //克隆位图对象的一部分。
+                System.Drawing.Rectangle cloneRect = new System.Drawing.Rectangle(left, top, 1, bottom - top);
+                Bitmap cloneBitmap = bmp.Clone(cloneRect, bmp.PixelFormat);
+                bmp.Dispose();
+                //cloneBitmap.Save(@"d:\123.png", ImageFormat.Png);
+                return cloneBitmap;
+            }
+            else
+            {
+                //克隆位图对象的一部分。
+                System.Drawing.Rectangle cloneRect = new System.Drawing.Rectangle(left, top, right - left, bottom - top);
+                Bitmap cloneBitmap = bmp.Clone(cloneRect, bmp.PixelFormat);
+                bmp.Dispose();
+                //cloneBitmap.Save(@"d:\123.png", ImageFormat.Png);
+                return cloneBitmap;
+            }
+
+        }
+
+        /// <summary>
+        /// 判断是否白色和纯透明色（10点的容差）
+        /// </summary>
+        public static bool IsWhite(System.Drawing.Color c)
+        {
+            //纯透明也是白色,RGB都为255为纯白
+            if (c.A < 10 || (c.R > 245 && c.G > 245 && c.B > 245))
+            {
+                return true;
+            }
+
+            return false;
+        }
+        #endregion
+    }
+    public class SaveImageModel
+    {
+        public string FilePath { get; set; }
+        public BitmapEncoder encoder { get; set; }
+        //public RenderTargetBitmap bmp { get; set; }
+    }
+    public class SaveModel
+    {
+        public int ImgWidth { get; set; }
+        public int ImgHeight { get; set; }
+        public BitmapEncoder encoder { get; set; }
+        public string filePathName { get; set; }
+        public RenderTargetBitmap bmp { get; set; }
+    }
+}

Common/system/JsonHelper.cs

@@ -0,0 +1,64 @@
+using Newtonsoft.Json;
+
+using System.Collections.Generic;
+using System.IO;
+
+namespace Common.system
+{
+    public class JsonHelper
+    {
+        #region Method
+
+        /// <summary>
+        /// 类对像转换成json格式
+        /// </summary>
+        /// <returns></returns>
+        public static string ToJson(object t)
+        {
+            return JsonConvert.SerializeObject(
+                t, Newtonsoft.Json.Formatting.None, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Include }
+                );
+        }
+        /// <summary>
+        /// 类对像转换成json格式
+        /// </summary>
+        /// <param name="t"></param>
+        /// <param name="HasNullIgnore">是否忽略NULL值</param>
+        /// <returns></returns>
+        public static string ToJson(object t, bool HasNullIgnore)
+        {
+            if (HasNullIgnore)
+            {
+                return JsonConvert.SerializeObject(t, Newtonsoft.Json.Formatting.Indented, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
+            }
+            else
+            {
+                return ToJson(t);
+            }
+        }
+
+        /// <summary>
+        /// json格式转换
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="strJson"></param>
+        /// <returns></returns>
+        public static T JsonToObj<T>(string strJson) where T : class
+        {
+            if (strJson != null && strJson != "") { return JsonConvert.DeserializeObject<T>(strJson); }
+
+            return null;
+        }
+
+        internal static List<T> JsonToList<T>(string respstr)
+        {
+            JsonSerializer serializer = new JsonSerializer();
+            StringReader sr = new StringReader(respstr);
+            object o = serializer.Deserialize(new JsonTextReader(sr), typeof(List<T>));
+            List<T> list = o as List<T>;
+            return list;
+        }
+
+        #endregion Method
+    }
+}

Common/system/KeyboardHookCommon.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 键盘钩子
+    /// 创建人：赵耀
+    /// 创建时间：2020年9月11日
+    /// </summary>
+    public class KeyboardHookCommon
+    {
+        /// <summary>
+        /// 全局按键按下
+        /// </summary>
+        public event KeyEventHandler KeyDownEvent;
+        /// <summary>
+        /// 窗口按键按下
+        /// </summary>
+        public event KeyPressEventHandler KeyPressEvent;
+        /// <summary>
+        /// 全局按键抬起
+        /// </summary>
+        public event KeyEventHandler KeyUpEvent;
+
+        public delegate int HookProc(int nCode, int wParam, IntPtr lParam);
+
+        private static int hKeyboardHook = 0; //声明键盘钩子处理的初始值
+                                              //值在Microsoft SDK的Winuser.h里查询
+        /// <summary>
+        /// 线程键盘钩子监听鼠标消息设为2，全局键盘监听鼠标消息设为13
+        /// </summary>
+        public const int WH_KEYBOARD_LL = 13;
+
+        /// <summary>
+        /// 声明KeyboardHookProcedure作为HookProc类型
+        /// </summary>
+        private HookProc KeyboardHookProcedure;
+
+        /// <summary>
+        /// 自己创建窗口按键 
+        /// </summary>
+        private const int WM_KEYDOWN = 0x100;//KEYDOWN
+        /// <summary>
+        /// 窗口按键抬起
+        /// </summary>
+        private const int WM_KEYUP = 0x101;//KEYUP
+        /// <summary>
+        /// 全局系统按键
+        /// </summary>
+        private const int WM_SYSKEYDOWN = 0x104;//SYSKEYDOWN
+        /// <summary>
+        /// 全局按键抬起
+        /// </summary>
+        private const int WM_SYSKEYUP = 0x105;//SYSKEYUP
+
+        //键盘结构
+        [StructLayout(LayoutKind.Sequential)]
+        public class KeyboardHookStruct
+        {
+            public int vkCode;  //定一个虚拟键码。该代码必须有一个价值的范围1至254
+            public int scanCode; // 指定的硬件扫描码的关键
+            public int flags;  // 键标志
+            public int time; // 指定的时间戳记的这个讯息
+            public int dwExtraInfo; // 指定额外信息相关的信息
+        }
+        //使用此功能，安装了一个钩子
+        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
+        public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
+
+
+        //调用此函数卸载钩子
+        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
+        public static extern bool UnhookWindowsHookEx(int idHook);
+
+
+        //使用此功能，通过信息钩子继续下一个钩子
+        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
+        public static extern int CallNextHookEx(int idHook, int nCode, int wParam, IntPtr lParam);
+
+        // 取得当前线程编号（线程钩子需要用到）
+        [DllImport("kernel32.dll")]
+        private static extern int GetCurrentThreadId();
+
+        //使用WINDOWS API函数代替获取当前实例的函数,防止钩子失效
+        [DllImport("kernel32.dll")]
+        public static extern IntPtr GetModuleHandle(string name);
+
+        //ToAscii职能的转换指定的虚拟键码和键盘状态的相应字符或字符
+        [DllImport("user32")]
+        public static extern int ToAscii(int uVirtKey, //[in] 指定虚拟关键代码进行翻译。
+                                         int uScanCode, // [in] 指定的硬件扫描码的关键须翻译成英文。高阶位的这个值设定的关键，如果是（不压）
+                                         byte[] lpbKeyState, // [in] 指针，以256字节数组，包含当前键盘的状态。每个元素（字节）的数组包含状态的一个关键。如果高阶位的字节是一套，关键是下跌（按下）。在低比特，如果设置表明，关键是对切换。在此功能，只有肘位的CAPS LOCK键是相关的。在切换状态的NUM个锁和滚动锁定键被忽略。
+                                         byte[] lpwTransKey, // [out] 指针的缓冲区收到翻译字符或字符。
+                                         int fuState); // [in] Specifies whether a menu is active. This parameter must be 1 if a menu is active, or 0 otherwise.
+
+        //获取按键的状态
+        [DllImport("user32")]
+        public static extern int GetKeyboardState(byte[] pbKeyState);
+
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
+        private static extern short GetKeyState(int vKey);
+
+        public void Start()
+        {
+            // 安装键盘钩子
+            if (hKeyboardHook == 0)
+            {
+                KeyboardHookProcedure = new HookProc(KeyboardHookProc);
+                hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProcedure, GetModuleHandle(System.Diagnostics.Process.GetCurrentProcess().MainModule.ModuleName), 0);
+                //hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProcedure, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
+                //************************************
+                //键盘线程钩子
+                //SetWindowsHookEx( 2,KeyboardHookProcedure, IntPtr.Zero, GetCurrentThreadId());//指定要监听的线程idGetCurrentThreadId(),
+                //键盘全局钩子,需要引用空间(using System.Reflection;)
+                //SetWindowsHookEx( 13,MouseHookProcedure,Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),0);
+                //
+                //关于SetWindowsHookEx (int idHook, HookProc lpfn, IntPtr hInstance, int threadId)函数将钩子加入到钩子链表中，说明一下四个参数：
+                //idHook 钩子类型，即确定钩子监听何种消息，上面的代码中设为2，即监听键盘消息并且是线程钩子，如果是全局钩子监听键盘消息应设为13，
+                //线程钩子监听鼠标消息设为7，全局钩子监听鼠标消息设为14。lpfn 钩子子程的地址指针。如果dwThreadId参数为0 或是一个由别的进程创建的
+                //线程的标识，lpfn必须指向DLL中的钩子子程。 除此以外，lpfn可以指向当前进程的一段钩子子程代码。钩子函数的入口地址，当钩子钩到任何
+                //消息后便调用这个函数。hInstance应用程序实例的句柄。标识包含lpfn所指的子程的DLL。如果threadId 标识当前进程创建的一个线程，而且子
+                //程代码位于当前进程，hInstance必须为NULL。可以很简单的设定其为本应用程序的实例句柄。threaded 与安装的钩子子程相关联的线程的标识符
+                //如果为0，钩子子程与所有的线程关联，即为全局钩子
+                //************************************
+                //如果SetWindowsHookEx失败
+                if (hKeyboardHook == 0)
+                {
+                    Stop();
+                    throw new Exception("安装键盘钩子失败");
+                }
+            }
+        }
+        public void Stop()
+        {
+            bool retKeyboard = true;
+
+
+            if (hKeyboardHook != 0)
+            {
+                retKeyboard = UnhookWindowsHookEx(hKeyboardHook);
+                hKeyboardHook = 0;
+            }
+            try
+            {
+
+                if (!(retKeyboard))
+                {
+                    throw new Exception("卸载钩子失败！");
+                }
+            }
+            catch (Exception)
+            {
+
+            }
+        }
+        ////接收SetWindowsHookEx返回值  
+        //private static int _hHookValue = 0;
+        private int KeyboardHookProc(int nCode, int wParam, IntPtr lParam)
+        {
+            // 侦听键盘事件
+            if ((nCode >= 0) && (KeyDownEvent != null || KeyUpEvent != null || KeyPressEvent != null))
+            {
+                KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
+                // raise KeyDown
+                if (KeyDownEvent != null && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))
+                {
+                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;
+                    KeyEventArgs e = new KeyEventArgs(keyData);
+                    KeyDownEvent(this, e);
+                }
+
+                //键盘按下
+                if (KeyPressEvent != null && wParam == WM_KEYDOWN)
+                {
+                    byte[] keyState = new byte[256];
+                    GetKeyboardState(keyState);
+
+                    byte[] inBuffer = new byte[2];
+                    if (ToAscii(MyKeyboardHookStruct.vkCode, MyKeyboardHookStruct.scanCode, keyState, inBuffer, MyKeyboardHookStruct.flags) == 1)
+                    {
+                        KeyPressEventArgs e = new KeyPressEventArgs((char)inBuffer[0]);
+                        KeyPressEvent(this, e);
+                    }
+                }
+
+                // 键盘抬起
+                if (KeyUpEvent != null && (wParam == WM_KEYUP || wParam == WM_SYSKEYUP))
+                {
+                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;
+                    KeyEventArgs e = new KeyEventArgs(keyData);
+                    KeyUpEvent(this, e);
+                }
+
+            }
+            //如果返回1，则结束消息，这个消息到此为止，不再传递。
+            //如果返回0或调用CallNextHookEx函数则消息出了这个钩子继续往下传递，也就是传给消息真正的接受者
+            return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
+        }
+        ~KeyboardHookCommon()
+        {
+            Stop();
+        }
+
+    }
+}

Common/system/LogHelper.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace Common.system
+{
+    public class LogHelper
+    {
+        public static readonly log4net.ILog loginfo = log4net.LogManager.GetLogger("loginfo");
+        public static readonly log4net.ILog logerror = log4net.LogManager.GetLogger("logerror");
+        public static void WriteInfoLog(string info)
+        {
+            if (loginfo.IsInfoEnabled)
+            {
+                loginfo.Info(info);
+            }
+        }
+
+        public static void WriteErrLog(string info, Exception ex)
+        {
+            if (logerror.IsErrorEnabled)
+            {
+                logerror.Error("[V " + FileToolsCommon.GetConfigValue("VersionName") + "]"+info, ex);
+            }
+        }
+    }
+}

Common/system/MouseEventCommon.cs

@@ -0,0 +1,95 @@
+using System.Runtime.InteropServices;
+
+namespace Common.system
+{
+    public class MouseEventCommon
+    {
+        //[DllImport("user32.dll")]
+        //static extern void mouse_event(MouseEventFlag flags, int dx, int dy, uint data, UIntPtr extraInfo);
+
+        [DllImport("user32")]
+        private static extern int mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
+        /// <summary>
+        /// 设置鼠标的坐标 
+        /// </summary>
+        /// <param name="x">横坐标</param>
+        /// <param name="y">纵坐标</param>
+        /// <returns></returns>
+        [DllImport("user32.dll")]
+        public static extern int SetCursorPos(int x, int y);
+
+        /// <summary>   
+        /// 获取鼠标的坐标   
+        /// </summary>   
+        /// <param name="lpPoint">传址参数，坐标point类型</param>   
+        /// <returns>获取成功返回真</returns>   
+
+
+        [DllImport("user32.dll", CharSet = CharSet.Auto)]
+        public static extern bool GetCursorPos(out POINT pt);
+
+        /// <summary>
+        /// 鼠标点击左键
+        /// </summary>
+        /// <param name="dx">坐标x</param>
+        /// <param name="dy">坐标Y</param>
+        /// <param name="data"></param>
+        public static void MouseLefClickEvent(int dx, int dy, int data)
+        {
+            GetCursorPos(out POINT pointRecord);
+            mouse_event((int)MouseEventFlag.MiddleDown, pointRecord.X, pointRecord.Y, data, 0);
+            mouse_event((int)MouseEventFlag.MiddleUp, pointRecord.X, pointRecord.Y, data, 0);
+        }
+        public static void MouseText(int dx, int dy)
+        {
+            mouse_event((int)MouseEventFlag.LeftDown, dx, dy, 0, 0);
+            mouse_event((int)MouseEventFlag.LeftUp, dx, dy, 0, 0);
+        }
+        /// <summary>
+        /// 鼠标点击中中键
+        /// </summary>
+        /// <param name="data"></param>
+        public static void MouseMiddleClickEvent(int data)
+        {
+            GetCursorPos(out POINT pointRecord);
+            mouse_event((int)MouseEventFlag.MiddleDown, pointRecord.X, pointRecord.Y, data, 0);
+            mouse_event((int)MouseEventFlag.MiddleUp, pointRecord.X, pointRecord.Y, data, 0);
+        }
+
+        public struct POINT
+        {
+            public int X;
+            public int Y;
+            public POINT(int x, int y)
+            {
+                this.X = x;
+                this.Y = y;
+            }
+
+        }
+
+        enum MouseEventFlag : uint
+        {
+            //移动鼠标 
+            Move = 0x0001,
+            //模拟鼠标左键按下 
+            LeftDown = 0x0002,
+            //模拟鼠标左键抬起 
+            LeftUp = 0x0004,
+            //模拟鼠标右键按下 
+            RightDown = 0x0008,
+            //模拟鼠标右键抬起 
+            RightUp = 0x0010,
+            //模拟鼠标中键按下 
+            MiddleDown = 0x0020,
+            //模拟鼠标中键抬起 
+            MiddleUp = 0x0040,
+            XDown = 0x0080,
+            XUp = 0x0100,
+            Wheel = 0x0800,
+            VirtualDesk = 0x4000,
+            //标示是否采用绝对坐标 
+            Absolute = 0x8000
+        }
+    }
+}

Common/system/NumUtil.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Common.system
+{
+    public class NumUtil
+    {
+        public static int unixTime()
+        {
+            double ms = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds;
+            int msl = (int)ms;
+            return msl;
+        }
+    }
+}

Common/system/PdfTrunImage.cs

@@ -0,0 +1,88 @@
+using O2S.Components.PDFRender4NET;
+
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 
+    /// Class to convert a pdf to an image using GhostScript DLL
+    /// Credit for this code go to:Rangel Avulso
+    /// i only fix a little bug and refactor a little
+    /// http://www.hrangel.com.br/index.php/2006/12/04/converter-pdf-para-imagem-jpeg-em-c/
+    /// </summary>
+    /// <seealso cref="http://www.hrangel.com.br/index.php/2006/12/04/converter-pdf-para-imagem-jpeg-em-c/"/>
+    public class PdfTrunImage
+    {
+        public enum Definition
+        {
+            One = 1, Two = 2, Three = 3, Four = 4, Five = 5, Six = 6, Seven = 7, Eight = 8, Nine = 9, Ten = 10
+        }
+
+        /// <summary>
+        /// 将PDF文档转换为图片的方法
+        /// </summary>
+        /// <param name="pdfInputPath">PDF文件路径</param>
+        /// <param name="imageOutputPath">图片输出路径</param>
+        /// <param name="imageName">生成图片的名字</param>
+        /// <param name="startPageNum">从PDF文档的第几页开始转换</param>
+        /// <param name="endPageNum">从PDF文档的第几页开始停止转换</param>
+        /// <param name="imageFormat">设置所需图片格式</param>
+        /// <param name="definition">设置图片的清晰度，数字越大越清晰</param>
+        public static List<string> ConvertPDF2Image(string pdfInputPath, string imageOutputPath,
+            string imageName, int startPageNum, int endPageNum, ImageFormat imageFormat, Definition definition)
+        {
+            List<string> images = new List<string>();
+            try
+            {
+                PDFFile pdfFile = PDFFile.Open(pdfInputPath);
+
+                if (!Directory.Exists(imageOutputPath))
+                {
+                    Directory.CreateDirectory(imageOutputPath);
+                }
+
+                // validate pageNum
+                if (startPageNum <= 0)
+                {
+                    startPageNum = 1;
+                }
+
+                if (endPageNum == 0 || endPageNum > pdfFile.PageCount)
+                {
+                    endPageNum = pdfFile.PageCount;
+                }
+                if (startPageNum > endPageNum)
+                {
+                    int tempPageNum = startPageNum;
+                    startPageNum = endPageNum;
+                    endPageNum = startPageNum;
+                }
+
+                // start to convert each page
+                for (int i = startPageNum; i <= endPageNum; i++)
+                {
+                    Bitmap pageImage = pdfFile.GetPageImage(i - 1, 56 * (int)definition);
+                    string imgPath = imageOutputPath + imageName + i.ToString() + "." + imageFormat.ToString();
+                    pageImage.Save(imgPath, imageFormat);
+                    images.Add(imgPath);
+                    // 返回的图片绝对路径集合
+                    pageImage.Dispose();
+                }
+
+                pdfFile.Dispose();
+                return images;
+            }
+            catch (System.Exception ex)
+            {
+                LogHelper.WriteErrLog("PDF转图片" +
+                    "【PdfTrunImage】" + ex.Message, ex);
+                images = new List<string>();
+                return images;
+            }
+        }
+    }
+}

Common/system/PrimaryScreen.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Drawing;
+using System.Runtime.InteropServices;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 获取系统DPI缩放倍数和真实大小
+    /// </summary>
+    public class PrimaryScreen
+    {
+        #region Win32 API
+        [DllImport("user32.dll")]
+        private static extern IntPtr GetDC(IntPtr ptr);
+        [DllImport("gdi32.dll")]
+        private static extern int GetDeviceCaps(
+       IntPtr hdc, // handle to DC
+       int nIndex // index of capability
+       );
+        [DllImport("user32.dll", EntryPoint = "ReleaseDC")]
+        private static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDc);
+        #endregion
+        #region DeviceCaps常量
+        /// <summary>
+        /// 屏幕的宽度（像素）；
+        /// </summary>
+        private const int HORZRES = 8;
+
+        /// <summary>
+        /// 屏幕的高度
+        /// </summary>
+        private const int VERTRES = 10;
+
+        /// <summary>
+        /// 沿屏幕宽度每逻辑英寸的像素数，在多显示器系统中，该值对所显示器相同
+        /// </summary>
+        private const int LOGPIXELSX = 88;
+
+        /// <summary>
+        /// 沿屏幕高度每逻辑英寸的像素数，在多显示器系统中，该值对所显示器相同；
+        /// </summary>
+        private const int LOGPIXELSY = 90;
+
+        /// <summary>
+        /// Windows NT：可视桌面的以像素为单位的高度。
+        /// </summary>
+        private const int DESKTOPVERTRES = 117;
+
+        /// <summary>
+        /// DESKTOPHORZRES：Windows NT：可视桌面的以像素为单位的宽度。如果设备支持一个可视桌面或双重显示则此值可能大于VERTRES；
+        /// </summary>
+        private const int DESKTOPHORZRES = 118;
+        #endregion
+
+        #region 属性
+        /// <summary>
+        /// 获取屏幕分辨率当前物理大小 设置缩放后
+        /// </summary>
+        public static Size WorkingArea
+        {
+            get
+            {
+                IntPtr hdc = GetDC(IntPtr.Zero);
+                Size size = new Size
+                {
+                    Width = GetDeviceCaps(hdc, HORZRES),
+                    Height = GetDeviceCaps(hdc, VERTRES)
+                };
+                ReleaseDC(IntPtr.Zero, hdc);
+                return size;
+            }
+        }
+        /// <summary>
+        /// 当前系统DPI_X 大小 一般为96
+        /// </summary>
+        public static int DpiX
+        {
+            get
+            {
+                IntPtr hdc = GetDC(IntPtr.Zero);
+                int DpiX = GetDeviceCaps(hdc, LOGPIXELSX);
+                ReleaseDC(IntPtr.Zero, hdc);
+                return DpiX;
+            }
+        }
+        /// <summary>
+        /// 当前系统DPI_Y 大小 一般为96
+        /// </summary>
+        public static int DpiY
+        {
+            get
+            {
+                IntPtr hdc = GetDC(IntPtr.Zero);
+                int DpiX = GetDeviceCaps(hdc, LOGPIXELSY);
+                ReleaseDC(IntPtr.Zero, hdc);
+                return DpiX;
+            }
+        }
+        /// <summary>
+        /// 获取真实设置的桌面分辨率大小
+        /// </summary>
+        public static Size DESKTOP
+        {
+            get
+            {
+                IntPtr hdc = GetDC(IntPtr.Zero);
+                Size size = new Size
+                {
+                    Width = GetDeviceCaps(hdc, DESKTOPHORZRES),
+                    Height = GetDeviceCaps(hdc, DESKTOPVERTRES)
+                };
+                ReleaseDC(IntPtr.Zero, hdc);
+                return size;
+            }
+        }
+
+        /// <summary>
+        /// 获取宽度缩放百分比
+        /// </summary>
+        public static float ScaleX
+        {
+            get
+            {
+                IntPtr hdc = GetDC(IntPtr.Zero);
+                /*int t = */
+                GetDeviceCaps(hdc, DESKTOPHORZRES);
+                /* int d = */
+                GetDeviceCaps(hdc, HORZRES);
+                float ScaleX = GetDeviceCaps(hdc, DESKTOPHORZRES) / (float)GetDeviceCaps(hdc, HORZRES);
+                ReleaseDC(IntPtr.Zero, hdc);
+                return ScaleX;
+            }
+        }
+        /// <summary>
+        /// 获取高度缩放百分比
+        /// </summary>
+        public static float ScaleY
+        {
+            get
+            {
+                IntPtr hdc = GetDC(IntPtr.Zero);
+                float ScaleY = (float)GetDeviceCaps(hdc, DESKTOPVERTRES) / GetDeviceCaps(hdc, VERTRES);
+                ReleaseDC(IntPtr.Zero, hdc);
+                return ScaleY;
+            }
+        }
+
+        /// <summary>
+        /// 缩放后的大小
+        /// </summary>
+        /// <returns></returns>
+        public static SizeF ScaleScreenSize => new SizeF(DESKTOP.Width / (DpiX / 96f), DESKTOP.Height / (DpiY / 96f));
+        /// <summary>
+        /// 获取缩放后的工作区域大小
+        /// </summary>
+        public static RectangleF ScaleWorkingAreaSize
+        {
+            get
+            {
+                RectangleF rect = System.Windows.Forms.Screen.GetWorkingArea(new System.Drawing.Point((int)ScaleScreenSize.Width, (int)ScaleScreenSize.Height));
+                return new RectangleF(((float)rect.X) / (DpiX / 96f), ((float)rect.Y) / (DpiX / 96f), ((float)rect.Width) / (DpiX / 96f), ((float)rect.Height) / (DpiY / 96f));
+            }
+        }
+        #endregion
+    }
+}

Common/system/QueueSync.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 队列操作类 默认队列数1000
+    /// 创建人：赵耀
+    /// 创建时间：2019年8月22日
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class QueueSync<T>
+    {
+        int _maxcount = 10000;
+        Queue<T> _queue = new Queue<T>();
+        /// <summary>
+        /// 获取该队列包含的元素数
+        /// </summary>
+        public int Count
+        {
+            get
+            {
+                if (_queue == null)
+                {
+                    return 0;
+                }
+                else
+                {
+                    return _queue.Count;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 默认1000
+        /// </summary>
+        public QueueSync() : this(1000) { }
+
+        /// <summary>
+        /// 定义一个指定容量的队列
+        /// </summary>
+        /// <param name="maxcount"></param>
+        public QueueSync(int maxcount)
+        {
+            //_maxcount = Math.Max(maxcount, _maxcount);
+            _maxcount = maxcount;
+        }
+
+        /// <summary>
+        /// 入队列
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public bool Enqueue(T obj)
+        {
+            bool result = false;
+            lock (this)
+            {
+                if (_queue.Count > _maxcount)
+                {
+                    _queue.Dequeue();
+                }
+                _queue.Enqueue(obj);
+                result = true;
+            }
+            return result;
+        }
+        /// <summary>
+        /// 出队列
+        /// </summary>
+        /// <returns></returns>
+        public T Dequeue()
+        {
+            T obj = default(T);
+            lock (this)
+            {
+                try
+                {
+                    obj = _queue.Dequeue();
+                }
+                catch
+                {
+
+                }
+            }
+            return obj;
+        }
+    }
+}

Common/system/SplashScreen.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Reflection;
+using System.Threading;
+using System.Windows.Forms;
+
+namespace Common.system
+{
+    /// <summary>
+    /// 解决闪屏  加载等待 
+    /// 创建人：赵耀
+    /// 创建时间：2018年11月27日
+    /// </summary>
+    public class SplashScreen
+    {
+        private static object _obj = new object();
+
+        private static Form _SplashForm = null;
+
+        private static Thread _SplashThread = null;
+
+        private delegate void ChangeFormTextdelegate(string s);
+
+        public static void Show(Type splashFormType)
+        {
+            if (_SplashThread != null)
+            {
+                return;
+            }
+
+            if (splashFormType == null)
+            {
+                throw (new Exception());
+            }
+
+            _SplashThread = new Thread(new ThreadStart(delegate ()
+            {
+                CreateInstance(splashFormType);
+                Application.Run(_SplashForm);
+            }))
+            {
+                IsBackground = true
+            };
+            _SplashThread.SetApartmentState(ApartmentState.STA);
+            _SplashThread.Start();
+        }
+
+        public static void ChangeTitle(string status)
+        {
+            ChangeFormTextdelegate de = new ChangeFormTextdelegate(ChangeText);
+            _SplashForm.Invoke(de, status);
+        }
+
+
+
+        public static void Close()
+        {
+            if (_SplashThread == null || _SplashForm == null)
+            {
+                return;
+            }
+
+            try
+            {
+                _SplashForm.Invoke(new MethodInvoker(_SplashForm.Close));
+            }
+            catch (Exception)
+            {
+            }
+            _SplashThread = null;
+            _SplashForm = null;
+        }
+
+        private static void ChangeText(string title)
+        {
+            _SplashForm.Text = title.ToString();
+        }
+
+
+
+        private static void CreateInstance(Type FormType)
+        {
+            if (_SplashForm == null)
+            {
+                lock (_obj)
+                {
+                    object obj = FormType.InvokeMember(null,
+                                        BindingFlags.DeclaredOnly |
+                                        BindingFlags.Public | BindingFlags.NonPublic |
+                                        BindingFlags.Instance | BindingFlags.CreateInstance, null, null, null);
+                    _SplashForm = obj as Form;
+                    _SplashForm.TopMost = true;
+                    _SplashForm.ShowInTaskbar = false;
+                    _SplashForm.BringToFront();
+                    _SplashForm.StartPosition = FormStartPosition.CenterScreen;
+                    if (_SplashForm == null)
+                    {
+                        throw (new Exception());
+                    }
+                }
+            }
+        }
+
+    }
+}

Common/system/XmlUtilHelper.cs

@@ -0,0 +1,192 @@
+using System;
+using System.Data;
+using System.IO;
+using System.Xml;
+using System.Xml.Serialization;
+
+namespace Common.system
+{
+
+    /// <summary>
+    /// 通用XML序列化和反序列化工具类
+    /// 创建人：赵耀
+    /// 创建时间：2018年11月16日
+    /// </summary>
+    public static class XmlUtilHelper
+    {
+        #region 反序列化
+        /// <summary>
+        /// 反序列化
+        /// </summary>
+        /// <param name="type">类型</param>
+        /// <param name="xml">XML字符串</param>
+        /// <returns></returns>
+        public static object Deserialize(Type type, string xml)
+        {
+            try
+            {
+                using (StringReader sr = new StringReader(xml))
+                {
+                    XmlSerializer xmldes = new XmlSerializer(type);
+                    return xmldes.Deserialize(sr);
+                }
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+        /// <summary>
+        /// 反序列化
+        /// </summary>
+        /// <param name="type"></param>
+        /// <param name="xml"></param>
+        /// <returns></returns>
+        public static object Deserialize(Type type, Stream stream)
+        {
+            XmlSerializer xmldes = new XmlSerializer(type);
+
+            return xmldes.Deserialize(stream);
+        }
+        /// <summary>
+        /// 反序列化实体
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="strXML"></param>
+        /// <returns></returns>
+        public static T DESerializer<T>(string strXML) where T : class
+        {
+            try
+            {
+                using (StringReader sr = new StringReader(strXML))
+                {
+                    XmlSerializer serializer = new XmlSerializer(typeof(T));
+                    return serializer.Deserialize(sr) as T;
+                }
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+
+        /// <summary>  
+        /// 从xml序列中反序列化  
+        /// </summary>  
+        /// <param name="objname"></param>  
+        /// <returns></returns>  
+        public static object Deserailize(Type type, string filename)
+        {
+            try
+            {
+                object obj;
+                if (!System.IO.File.Exists(filename))
+                {
+                    throw new Exception("指定文件不存在");
+                }
+                //Xml格式反序列化  
+                using (Stream stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read))
+                {
+                    XmlSerializer formatter = new XmlSerializer(type);
+                    obj = formatter.Deserialize(stream);
+                    stream.Close();
+                }
+                return obj;
+            }
+            catch (Exception)
+            {
+                //Logger.Log4NetHelp.Error("反序列化失败:", e);
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// 将xml转为Datable
+        /// </summary>
+        public static DataTable XmlToDataTable(string xmlStr)
+        {
+            if (!string.IsNullOrEmpty(xmlStr))
+            {
+                StringReader StrStream = null;
+                XmlTextReader Xmlrdr = null;
+                try
+                {
+                    DataSet ds = new DataSet();
+                    //读取字符串中的信息  
+                    StrStream = new StringReader(xmlStr);
+                    //获取StrStream中的数据  
+                    Xmlrdr = new XmlTextReader(StrStream);
+                    //ds获取Xmlrdr中的数据                 
+                    ds.ReadXml(Xmlrdr);
+                    return ds.Tables[0];
+                }
+                catch (Exception)
+                {
+                    return null;
+                }
+                finally
+                {
+                    //释放资源  
+                    if (Xmlrdr != null)
+                    {
+                        Xmlrdr.Close();
+                        StrStream.Close();
+                        StrStream.Dispose();
+                    }
+                }
+            }
+            return null;
+        }
+
+        #endregion
+
+        #region 序列化
+        /// <summary>
+        /// 实体类转XML
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="obj"></param>
+        /// <returns></returns>
+        public static string XmlSerialize<T>(T obj)
+        {
+            using (StringWriter sw = new StringWriter())
+            {
+                Type t = obj.GetType();
+                XmlSerializer serializer = new XmlSerializer(obj.GetType());
+                serializer.Serialize(sw, obj);
+                sw.Close();
+                return sw.ToString();
+            }
+        }
+        /// <summary>
+        /// 序列化
+        /// </summary>
+        /// <param name="type">类型</param>
+        /// <param name="obj">对象</param>
+        /// <returns></returns>
+        public static string Serializer(Type type, object obj)
+        {
+            MemoryStream Stream = new MemoryStream();
+            XmlSerializer xml = new XmlSerializer(type);
+            try
+            {
+                //序列化对象
+                xml.Serialize(Stream, obj);
+            }
+            catch (InvalidOperationException)
+            {
+                //Logger.Log4NetHelp.Error("序列化失败:", ex);
+            }
+            Stream.Position = 0;
+            StreamReader sr = new StreamReader(Stream);
+            string str = sr.ReadToEnd();
+
+            sr.Dispose();
+            Stream.Dispose();
+
+            return str;
+        }
+
+        #endregion
+    }
+}

Common/system/ZJClippingBorder.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+
+namespace Common.system
+{
+    public class ZJClippingBorder : Border
+    {
+        private object _oldClip;
+
+        protected override void OnRender(DrawingContext dc)
+        {
+            OnApplyChildClip();
+            base.OnRender(dc);
+        }
+
+        public override UIElement Child
+        {
+            get => base.Child;
+            set
+            {
+                if (Child != value)
+                {
+                    if (Child != null)
+                    {
+                        Child.SetValue(ClipProperty, _oldClip);
+                    }
+
+                    if (value != null)
+                    {
+                        _oldClip = value.ReadLocalValue(ClipProperty);
+                    }
+                    else
+                    {
+                        // If we dont set it to null we could leak a Geometry object
+                        _oldClip = null;
+                    }
+
+                    base.Child = value;
+                }
+            }
+        }
+
+        protected virtual void OnApplyChildClip()
+        {
+            UIElement child = Child;
+            if (child != null)
+            {
+                double top = Math.Max(CornerRadius.TopLeft, CornerRadius.TopRight);
+                double bottom = Math.Max(CornerRadius.BottomLeft, CornerRadius.BottomRight);
+                double max = Math.Max(top, bottom);
+                Size size = RenderSize;
+                double width = size.Width - (BorderThickness.Left + BorderThickness.Right);
+                double height = size.Height - (BorderThickness.Top + BorderThickness.Bottom);
+                Geometry result = new RectangleGeometry(new Rect(0, 0, width, height), max, max);
+                double halfWidth = width / 2;
+                double halfHeight = height / 2;
+
+                if (CornerRadius.TopLeft == 0)
+                {
+                    result = new CombinedGeometry(
+                        GeometryCombineMode.Union,
+                        result,
+                        new RectangleGeometry(new Rect(0, 0, halfWidth, halfHeight))
+                    );
+                }
+
+                if (CornerRadius.TopRight == 0)
+                {
+                    result = new CombinedGeometry(GeometryCombineMode.Union, result, new RectangleGeometry
+                (new Rect(halfWidth, 0, halfWidth, halfHeight)));
+                }
+
+                if (CornerRadius.BottomLeft == 0)
+                {
+                    result = new CombinedGeometry
+                  (GeometryCombineMode.Union, result, new RectangleGeometry
+                  (new Rect(0, halfHeight, halfWidth, halfHeight)));
+                }
+                if (CornerRadius.BottomRight == 0)
+                {
+                    result = new CombinedGeometry
+                  (
+                GeometryCombineMode.Union,
+                result,
+                new RectangleGeometry(new Rect(halfWidth, halfHeight, halfWidth, halfHeight))
+                );
+                }
+                child.Clip = result;
+            }
+        }
+    }
+}

XHPZ.Desktop/APP.cs

@@ -0,0 +1,242 @@
+using Common.system;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Security.Principal;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Threading;
+
+using TStudyDigitalPen.HID;
+
+namespace XHPZ.Desktop
+{
+    public partial class APP : Application
+    {
+        #region 全局变量
+        /// <summary>
+        /// 后台线程帮助类
+        /// </summary>
+        public static BackgroundWorkerHelper BackgroundWorkerHelper => BackgroundWorkerHelper.GetInstance();
+
+        #region 点阵笔
+        /// <summary>
+        /// 点阵笔
+        /// </summary>
+        public static DigitalPenHID digitalPen;
+        /// <summary>
+        /// 笔序号
+        /// </summary>
+        public static string PenSerial;
+        /// <summary>
+        /// 笔状态，是否已连接
+        /// </summary>
+        public static bool PenStatus = false;
+        /// <summary>
+        /// 手写板状态，是否已连接
+        /// </summary>
+        public static bool BoardStatus = false;
+        #endregion
+        #region 腾千里手写笔
+        ///// <summary>
+        ///// 腾千里手写笔事件
+        ///// </summary>
+        //public static PenEvents TQLPenevents;
+        ///// <summary>
+        ///// 腾千里手写笔是否已连接
+        ///// </summary>
+        //public static bool TQLPenStatus = false;
+        #endregion
+        #region 页面
+        /// <summary>
+        /// 批注
+        /// </summary>
+        //public static PracticeWindow W_PracticeWindow = null;
+        #endregion
+        #endregion
+
+        [STAThread]
+        private static void Main()
+        {
+            StopSameProcess();
+            try
+            {
+                #region 强制以管理员方式运行 修改人：赵耀 修改时间：2020年9月7日
+                WindowsIdentity identity = WindowsIdentity.GetCurrent();
+                WindowsPrincipal principal = new WindowsPrincipal(identity);
+                //判断当前登录用户是否为管理员
+                //if (principal.IsInRole(WindowsBuiltInRole.Administrator))
+                //{
+                //    //如果是管理员，则直接运行
+                //    W_CreateAMicroLessonWindow = new CreateAMicroLessonWindow();
+                //    // 定义Application对象作为整个应用程序入口
+                //    Application app = new Application();
+                //    app.Run(W_CreateAMicroLessonWindow);
+                //    //Application.Run(W_CreateAMicroLessonWindow);
+                //}
+                //else
+                //{
+                //    //创建启动对象
+                //    System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo
+                //    {
+                //        UseShellExecute = true,
+                //        WorkingDirectory = Environment.CurrentDirectory,
+                //        FileName = Assembly.GetExecutingAssembly().Location,
+                //        //设置启动动作,确保以管理员身份运行
+                //        Verb = "runas"
+                //    };
+                //    try
+                //    {
+                //        System.Diagnostics.Process.Start(startInfo);
+                //    }
+                //    catch
+                //    {
+                //        return;
+                //    }
+                //    //退出
+                //    //Current.Shutdown();
+                //    Environment.Exit(0);
+
+                //}
+                #endregion
+
+                try
+                {
+                    if (Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "temp"))//清除临时文件
+                    {
+                        Directory.Delete(AppDomain.CurrentDomain.BaseDirectory + "temp", true);
+                    }
+                }
+                catch (Exception)
+                {
+                }
+
+                if (principal.IsInRole(WindowsBuiltInRole.Administrator))
+                {
+                    //如果是管理员，则直接运行
+                    MainWindow mainWindow = new MainWindow();
+                    // 定义Application对象作为整个应用程序入口
+                    Application app = new Application();
+                    app.Run(mainWindow);
+                }
+                else
+                {
+                    //创建启动对象
+                    System.Diagnostics.ProcessStartInfo startInfo = new System.Diagnostics.ProcessStartInfo
+                    {
+                        UseShellExecute = true,
+                        WorkingDirectory = Environment.CurrentDirectory,
+                        FileName = Assembly.GetExecutingAssembly().Location,
+                        //设置启动动作,确保以管理员身份运行
+                        Verb = "runas"
+                    };
+                    try
+                    {
+                        System.Diagnostics.Process.Start(startInfo);
+                    }
+                    catch
+                    {
+                        return;
+                    }
+                    //退出
+                    //Current.Shutdown();
+                    Environment.Exit(0);
+
+                }
+            }
+            catch (Exception ex)
+            {
+
+                string ErrMessage = "【进程】(Main):进程意外关闭。 " + ex.Message;
+                LogHelper.WriteErrLog(ErrMessage, ex);
+            }
+        }
+
+        #region 杀死已存在的进程
+        /// <summary>
+        /// 结束已运行的程序
+        /// </summary>
+        private static void StopSameProcess()
+        {
+            Process current = Process.GetCurrentProcess();
+            Process[] processList = Process.GetProcesses();
+            foreach (Process process in processList)
+            {
+                if (process.ProcessName.ToUpper() == "星火批注")
+                {
+                    if (process.Id != current.Id) //忽略当前进程
+                    {
+                        try
+                        {
+                            process.Kill(); //结束进程
+                        }
+                        catch (Exception)
+                        {
+                        }
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// 杀死正在运行的ffmpeg
+        /// </summary>
+        public static void Killffmpeg()
+        {
+            Process[] KillProcessArray = Process.GetProcessesByName("ffmpeg");
+            foreach (Process KillProcess in KillProcessArray)
+            {
+                KillProcess.Kill();
+            }
+        }
+        #endregion
+
+        /// <summary>
+        /// 错误处理
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void MyApp_DispatcherUnhandledException(object sender, DispatcherUnhandledExceptionEventArgs e)
+        {
+            LogHelper.WriteErrLog("未标示错误：" + e.Exception.Message, e.Exception);
+            //MessageWindow.Show("程序异常." + Environment.NewLine + e.Exception.Message);
+            e.Handled = true;
+        }
+
+
+        #region 内存处理 -创建人：赵耀 -创建时间：2020年8月12日
+        /// <summary>
+        /// 内存释放压缩
+        /// </summary>
+        /// <param name="e"></param>
+        protected override void OnStartup(StartupEventArgs e)
+        {
+            //private LierdaCracker cracker = new LierdaCracker();
+            //cracker.Cracker(5000);//间隔时间
+            //base.OnStartup(e);
+            new Thread(o =>
+            {
+                while (true)
+                {
+                    try
+                    {
+                        //FreeMemoryHelper.SetDate();
+                        FreeMemoryHelper.ReallocateMemory();
+                        Thread.Sleep(20000);//暂定每20秒释放一次
+                    }
+                    catch (Exception ex)
+                    {
+                        LogHelper.WriteErrLog("【释放内存（MyApp）" + ex.Message, ex);
+                    }
+                }
+            }).Start();
+        }
+
+        #endregion 内存处理 -创建人：赵耀 -创建时间：2020年8月12日
+    }
+}

XHPZ.Desktop/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.2" />
+    </startup>
+</configuration>

XHPZ.Desktop/App.xaml

@@ -0,0 +1,9 @@
+<Application x:Class="XHPZ.Desktop.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:XHPZ.Desktop"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>

XHPZ.Desktop/App.xaml.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace XHPZ.Desktop
+{
+    /// <summary>
+    /// App.xaml 的交互逻辑
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+}

XHPZ.Desktop/MainWindow.xaml

@@ -0,0 +1,12 @@
+<Window x:Class="XHPZ.Desktop.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:XHPZ.Desktop"
+        mc:Ignorable="d"
+        Title="MainWindow" Height="450" Width="800">
+    <Grid>
+        
+    </Grid>
+</Window>

XHPZ.Desktop/MainWindow.xaml.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+using Common.system;
+
+namespace XHPZ.Desktop
+{
+    /// <summary>
+    /// MainWindow.xaml 的交互逻辑
+    /// </summary>
+    public partial class MainWindow : Window
+    {
+        public MainWindow()
+        {
+            InitializeComponent();
+            LogHelper.WriteInfoLog("启动");
+        }
+    }
+}

XHPZ.Desktop/Properties/AssemblyInfo.cs

@@ -0,0 +1,55 @@
+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Windows;
+
+// 有关程序集的一般信息由以下
+// 控制。更改这些特性值可修改
+// 与程序集关联的信息。
+[assembly: AssemblyTitle("XHPZ.Desktop")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("XHPZ.Desktop")]
+[assembly: AssemblyCopyright("Copyright ©  2021")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// 将 ComVisible 设置为 false 会使此程序集中的类型
+//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
+//请将此类型的 ComVisible 特性设置为 true。
+[assembly: ComVisible(false)]
+
+//若要开始生成可本地化的应用程序，请设置
+//.csproj 文件中的 <UICulture>CultureYouAreCodingWith</UICulture>
+//例如，如果您在源文件中使用的是美国英语，
+//使用的是美国英语，请将 <UICulture> 设置为 en-US。  然后取消
+//对以下 NeutralResourceLanguage 特性的注释。  更新
+//以下行中的“en-US”以匹配项目文件中的 UICulture 设置。
+
+//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
+
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None, //主题特定资源词典所处位置
+                                     //(未在页面中找到资源时使用，
+                                     //或应用程序资源字典中找到时使用)
+    ResourceDictionaryLocation.SourceAssembly //常规资源词典所处位置
+                                              //(未在页面中找到资源时使用，
+                                              //、应用程序或任何主题专用资源字典中找到时使用)
+)]
+
+
+// 程序集的版本信息由下列四个值组成: 
+//
+//      主版本
+//      次版本
+//      生成号
+//      修订号
+//
+//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值
+//通过使用 "*"，如下所示:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

XHPZ.Desktop/Properties/Resources.Designer.cs

@@ -0,0 +1,70 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     此代码由工具生成。
+//     运行时版本: 4.0.30319.42000
+//
+//     对此文件的更改可能导致不正确的行为，如果
+//     重新生成代码，则所做更改将丢失。
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+namespace XHPZ.Desktop.Properties
+{
+    /// <summary>
+    ///   强类型资源类，用于查找本地化字符串等。
+    /// </summary>
+    // 此类是由 StronglyTypedResourceBuilder
+    // 类通过类似于 ResGen 或 Visual Studio 的工具自动生成的。
+    // 若要添加或删除成员，请编辑 .ResX 文件，然后重新运行 ResGen
+    // (以 /str 作为命令选项)，或重新生成 VS 项目。
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources
+    {
+
+        private static global::System.Resources.ResourceManager resourceMan;
+
+        private static global::System.Globalization.CultureInfo resourceCulture;
+
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources()
+        {
+        }
+
+        /// <summary>
+        ///   返回此类使用的缓存 ResourceManager 实例。
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager
+        {
+            get
+            {
+                if ((resourceMan == null))
+                {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("XHPZ.Desktop.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+
+        /// <summary>
+        ///   重写当前线程的 CurrentUICulture 属性，对
+        ///   使用此强类型资源类的所有资源查找执行重写。
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture
+        {
+            get
+            {
+                return resourceCulture;
+            }
+            set
+            {
+                resourceCulture = value;
+            }
+        }
+    }
+}

XHPZ.Desktop/Properties/Resources.resx

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>

XHPZ.Desktop/Properties/Settings.Designer.cs

@@ -0,0 +1,29 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:4.0.30319.42000
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+
+namespace XHPZ.Desktop.Properties
+{
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
+    {
+
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+        public static Settings Default
+        {
+            get
+            {
+                return defaultInstance;
+            }
+        }
+    }
+}

XHPZ.Desktop/Properties/Settings.settings

@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
+  <Profiles>
+    <Profile Name="(Default)" />
+  </Profiles>
+  <Settings />
+</SettingsFile>

XHPZ.Desktop/Properties/app.manifest

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="MyApplication.app" />
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
+        <!-- UAC 清单选项
+             如果想要更改 Windows 用户帐户控制级别，请使用
+             以下节点之一替换 requestedExecutionLevel 节点。n
+        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
+        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
+        <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
+
+            指定 requestedExecutionLevel 元素将禁用文件和注册表虚拟化。
+            如果你的应用程序需要此虚拟化来实现向后兼容性，则删除此
+            元素。
+        -->
+        <requestedExecutionLevel level="requireAdministrator" uiAccess="false" />
+      </requestedPrivileges>
+      <applicationRequestMinimum>
+        <defaultAssemblyRequest permissionSetReference="Custom" />
+        <PermissionSet class="System.Security.PermissionSet" version="1" ID="Custom" SameSite="site" Unrestricted="true" />
+      </applicationRequestMinimum>
+    </security>
+  </trustInfo>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- 设计此应用程序与其一起工作且已针对此应用程序进行测试的
+           Windows 版本的列表。取消评论适当的元素，
+           Windows 将自动选择最兼容的环境。 -->
+      <!-- Windows Vista -->
+      <!--<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}" />-->
+      <!-- Windows 7 -->
+      <!--<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />-->
+      <!-- Windows 8 -->
+      <!--<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />-->
+      <!-- Windows 8.1 -->
+      <!--<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />-->
+      <!-- Windows 10 -->
+      <!--<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />-->
+    </application>
+  </compatibility>
+  <!-- 指示该应用程序可以感知 DPI 且 Windows 在 DPI 较高时将不会对其进行
+       自动缩放。Windows Presentation Foundation (WPF)应用程序自动感知 DPI，无需
+       选择加入。选择加入此设置的 Windows 窗体应用程序(目标设定为 .NET Framework 4.6 )还应
+       在其 app.config 中将 "EnableWindowsFormsHighDpiAutoResizing" 设置设置为 "true"。-->
+  <!--
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true</dpiAware>
+    </windowsSettings>
+  </application>
+  -->
+  <!-- 启用 Windows 公共控件和对话框的主题(Windows XP 和更高版本) -->
+  <!--
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity
+          type="win32"
+          name="Microsoft.Windows.Common-Controls"
+          version="6.0.0.0"
+          processorArchitecture="*"
+          publicKeyToken="6595b64144ccf1df"
+          language="*"
+        />
+    </dependentAssembly>
+  </dependency>
+  -->
+</assembly>

XHPZ.Desktop/XHPZ.Desktop.csproj

@@ -0,0 +1,130 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{82B6341B-3566-4E1A-8B0C-5CAA90C30005}</ProjectGuid>
+    <OutputType>WinExe</OutputType>
+    <RootNamespace>XHPZ.Desktop</RootNamespace>
+    <AssemblyName>星火批注</AssemblyName>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <WarningLevel>4</WarningLevel>
+    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+    <Deterministic>true</Deterministic>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <TargetZone>LocalIntranet</TargetZone>
+  </PropertyGroup>
+  <PropertyGroup>
+    <GenerateManifests>false</GenerateManifests>
+  </PropertyGroup>
+  <PropertyGroup>
+    <ApplicationManifest>Properties\app.manifest</ApplicationManifest>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="log4net">
+      <HintPath>..\Common\dlls\log4net.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xaml">
+      <RequiredTargetFramework>4.0</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="TQLComm">
+      <HintPath>..\Common\dlls\TQLComm.dll</HintPath>
+    </Reference>
+    <Reference Include="TStudy.DigitalPen">
+      <HintPath>..\Common\dlls\TStudy.DigitalPen.dll</HintPath>
+    </Reference>
+    <Reference Include="WindowsBase" />
+    <Reference Include="PresentationCore" />
+    <Reference Include="PresentationFramework" />
+  </ItemGroup>
+  <ItemGroup>
+    <Page Include="MainWindow.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
+    <Compile Include="APP.cs" />
+    <Compile Include="MainWindow.xaml.cs">
+      <DependentUpon>MainWindow.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Properties\AssemblyInfo.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
+    <Compile Include="Properties\Settings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Settings.settings</DependentUpon>
+      <DesignTimeSharedInput>True</DesignTimeSharedInput>
+    </Compile>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <None Include="Properties\app.manifest" />
+    <None Include="Properties\Settings.settings">
+      <Generator>SettingsSingleFileGenerator</Generator>
+      <LastGenOutput>Settings.Designer.cs</LastGenOutput>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Common\Common.csproj">
+      <Project>{808a7075-5af5-46b3-8ef6-514c0b5fa8d7}</Project>
+      <Name>Common</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="CheckPoint.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </EmbeddedResource>
+    <EmbeddedResource Include="RobotDotMatrix.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </EmbeddedResource>
+    <EmbeddedResource Include="RobotUsbWrapper.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </EmbeddedResource>
+    <EmbeddedResource Include="SonixUSB.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

XHPZ.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30804.86
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XHPZ.Desktop", "XHPZ.Desktop\XHPZ.Desktop.csproj", "{82B6341B-3566-4E1A-8B0C-5CAA90C30005}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Common", "Common\Common.csproj", "{808A7075-5AF5-46B3-8EF6-514C0B5FA8D7}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{82B6341B-3566-4E1A-8B0C-5CAA90C30005}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{82B6341B-3566-4E1A-8B0C-5CAA90C30005}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{82B6341B-3566-4E1A-8B0C-5CAA90C30005}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{82B6341B-3566-4E1A-8B0C-5CAA90C30005}.Release|Any CPU.Build.0 = Release|Any CPU
+		{808A7075-5AF5-46B3-8EF6-514C0B5FA8D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{808A7075-5AF5-46B3-8EF6-514C0B5FA8D7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{808A7075-5AF5-46B3-8EF6-514C0B5FA8D7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{808A7075-5AF5-46B3-8EF6-514C0B5FA8D7}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {FC5F78D4-21FE-44F0-952C-9F5C358214C6}
+	EndGlobalSection
+EndGlobal