代码优化

XHWK.WKTool/CreateAMicroLessonWindow.xaml.cs

 
 namespace XHWK.WKTool
 {
+    using system;
+
     /// <summary>
     /// 创建微课
     /// </summary>

XHWK.WKTool/DAL/DAL_Upload.cs

 
 namespace XHWK.WKTool.DAL
 {
+    using system;
+
     /// <summary>
     /// 上传相关方法 创建人：赵耀 创建时间：2020年9月4日
     /// </summary>

XHWK.WKTool/DAL/XHApi.cs

 
 namespace XHWK.WKTool.DAL
 {
+    using system;
+
     public class XHApi
     {
         /// <summary>

XHWK.WKTool/LoginWindow.xaml.cs

 
 namespace XHWK.WKTool
 {
+    using system;
+
     /// <summary>
     /// LoginWindow.xaml 的交互逻辑
     /// </summary>

XHWK.WKTool/MainWindow.xaml.cs

                             }
                             if (string.IsNullOrWhiteSpace(videoinfo.VideoSize) || videoinfo.VideoSize == "0 MB")
                             {
-                                videoinfo.VideoSize = FileToolsCommon.GetFileSizeByMB(videoinfo.VideoPath).ToString(CultureInfo.InvariantCulture) + " MB";
+                                videoinfo.VideoSize = FileToolsCommon.GetFileSizeByMb(videoinfo.VideoPath).ToString(CultureInfo.InvariantCulture) + " MB";
                                 videoinfo.VideoSizebyte = FileToolsCommon.GetFileSize(videoinfo.VideoPath);
                             }
                             _modelVideoList.Add(videoinfo);
                         string thumbnailPath = FileToolsCommon.GetDirectoryName(_videoSavePathName) + "ThumbnailPath/";
                         FileToolsCommon.CreateDirectory(thumbnailPath);
                         //缩略图存储位置
-                        string thumbnailPathName = thumbnailPath + FileToolsCommon.GetIOFileName(_videoSavePathName).Replace(".", "") + ".JPG";
+                        string thumbnailPathName = thumbnailPath + FileToolsCommon.GetIoFileName(_videoSavePathName).Replace(".", "") + ".JPG";
                         FileToolsCommon.DeleteFile(thumbnailPathName);
                         _videoInfo.RSTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                         _videoInfo.VideoPath = _videoSavePathName;
                     LogHelper.WriteErrLog("打印服务授权过期：" + keyCheckResult, null);
                     _gbInitDone = false;
                 }
-                else if (keyCheckResult.Substring(0, 1) == "0")
-                {
-                }
             }
             catch (Exception ex)
             {

XHWK.WKTool/ScreenRecordingToolbarWindow.xaml.cs

 
 namespace XHWK.WKTool
 {
+    using system;
+
     /// <summary>
     /// 录屏工具栏
     /// </summary>
                             string thumbnailPath = FileToolsCommon.GetDirectoryName(_videoSavePathName) + "ThumbnailPath/";
                             FileToolsCommon.CreateDirectory(thumbnailPath);
                             //缩略图存储位置
-                            string thumbnailPathName = thumbnailPath + FileToolsCommon.GetIOFileName(_videoSavePathName).Replace(".", "") + ".JPG";
+                            string thumbnailPathName = thumbnailPath + FileToolsCommon.GetIoFileName(_videoSavePathName).Replace(".", "") + ".JPG";
                             _videoInfo.RSTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                             _videoInfo.VideoPath = _videoSavePathName;
                             _videoInfo.ThumbnailPath = thumbnailPathName;

XHWK.WKTool/Skin/SkinConfig.cs

 
 namespace XHWK.WKTool.Skin
 {
+    using system;
+
     /// <summary>
     /// 皮肤配置
     /// 创建人：赵耀

XHWK.WKTool/UControl/Uc_VideoItem.xaml.cs

 
 namespace XHWK.WKTool.UControl
 {
+    using system;
+
     /// <summary>
     /// 视频信息
     /// </summary>
             {
                 ImgVideo.Source = ImageHelper.ReadBitmapImageFile(VideoModel.ThumbnailPath);// new BitmapImage(new Uri(VideoModel.ThumbnailPath));
             }
-            string videoName = FileToolsCommon.GetIOFileNameNoExtension(VideoModel.VideoPath);
+            string videoName = FileToolsCommon.GetIoFileNameNoExtension(VideoModel.VideoPath);
             TbName.Text = videoName.Length > 11 ? videoName.Substring(0, 11) + "..." : videoName;
             TbName.ToolTip = videoName;
             lblDateSize.Content = VideoModel.RSTime + " " + VideoModel.VideoSize;

XHWK.WKTool/VideoClipWindow.xaml.cs

 
 namespace XHWK.WKTool
 {
+    using system;
+
     /// <summary>
     /// 视频剪辑
     /// VideoClipWindow.xaml 的交互逻辑
             }
             dispatcherTimer.Stop();
             MoviePause();
-            string Extension = FileToolsCommon.GetIOExtension(VideoPath);
-            string FileName = FileToolsCommon.GetIOFileNameNoExtension(VideoPath);
+            string Extension = FileToolsCommon.GetIoExtension(VideoPath);
+            string FileName = FileToolsCommon.GetIoFileNameNoExtension(VideoPath);
             System.Windows.Forms.SaveFileDialog saveDg = new System.Windows.Forms.SaveFileDialog();
             saveDg.Filter = "(*" + Extension + ")|*" + Extension;// + "|(*.MP4)|*.MP4";
             //saveDg.FileName = tableName + DateTime.Now.ToString("yyyy-MM-dd_hh-mm-ss") + "";

XHWK.WKTool/system/FFMpeg.cs

             errMessage = null;
             //路径
             FileToolsCommon.GetDirectoryName(filePath);
-            string extension = FileToolsCommon.GetIOExtension(filePath); //扩展名
+            string extension = FileToolsCommon.GetIoExtension(filePath); //扩展名
             //文件保存路径
             string pathName = GetRsFilePathName(filePath);
             Process[] killProcessArray = Process.GetProcessesByName("ffmpeg");
             //路径
             string path = FileToolsCommon.GetDirectoryName(filePath);
             //Path.GetFileName(FilePath);//获取文件名
-            string extension = FileToolsCommon.GetIOExtension(filePath); //扩展名
+            string extension = FileToolsCommon.GetIoExtension(filePath); //扩展名
             string tempFilePath = path + "_temppath/";
             //创建临时目录
             FileToolsCommon.CreateDirectory(tempFilePath);
                 else
                 {
                     int num = 0;
-                    while (FileToolsCommon.GetFileSizeByMB(logName) > 2)
+                    while (FileToolsCommon.GetFileSizeByMb(logName) > 2)
                     {
                         num++;
                         logName = logFilePath + logFileName + "_" + num + ".log";

XHWK.WKTool/system/FileToolsCommon.cs

-using System;
-using System.Configuration;
-using System.IO;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Windows.Forms;
-
-namespace Common.system
+namespace XHWK.WKTool.system
 {
+    using System;
+    using System.Configuration;
+    using System.IO;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Windows.Forms;
+
     /// <summary>
     /// 文件工具公共方法
     /// 创建人：赵耀
         /// <summary>
         /// 获取文件的绝对路径
         /// </summary>
-        /// <param name="Path">相对路径</param>
+        /// <param name="path">相对路径</param>
         /// <returns></returns>
-        public static string GetFileAbsolutePath(string Path = "")
+        public static string GetFileAbsolutePath(string path = "")
         {
             try
             {
-                if (!string.IsNullOrWhiteSpace(Path))
+                if (!string.IsNullOrWhiteSpace(path))
                 {
-                    Path = Path.Replace("\\", "/");
-                    if (Path != "/")
+                    path = path.Replace("\\", "/");
+                    if (path != "/")
                     {
-                        if (Path.Substring(1, 1) == ":")
+                        if (path.Substring(1, 1) == ":")
                         {
-                            return Path;
+                            return path;
                         }
-
-                        if (Path.Substring(0, 1) != "/")
+                        if (path.Substring(0, 1) != "/")
                         {
-                            Path = "/" + Path;
+                            path = "/" + path;
                         }
                     }
                 }
-                string AbsolutePath = Application.StartupPath.ToString().Replace("\\", "/") + Path;
-                return AbsolutePath;
+                string absolutePath = Application.StartupPath.Replace("\\", "/") + path;
+                return absolutePath;
             }
             catch (Exception)
             {
-                return Path;
+                return path;
             }
         }
+
         /// <summary>
         /// 获取合法路径 结尾带/
         /// </summary>
         /// <returns></returns>
-        public static string GetLegalPath(string FilePath)
+        public static string GetLegalPath(string filePath)
         {
-            FilePath = System.IO.Path.Combine(FilePath.Replace("\\", "/"));
-            FilePath += (FilePath.Substring(FilePath.Length - 1, 1) == "/" ? "" : "/");
-            return 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>
+        /// <param name="filePathName">绝对路径</param>
+        /// <param name="errMessage">返回错误</param>
         /// <returns></returns>
-        public static bool IsLegalPath(string FilePathName, out string ErrMessage)
+        public static bool IsLegalPath(string filePathName, out string errMessage)
         {
-            string FilePath;
-            string FileName;
-            ErrMessage = "";
+            string filePath;
+            string fileName;
+            errMessage = "";
             try
             {
-                FilePathName = GetLegalPath(FilePathName);
-                FilePath = GetDirectoryName(FilePathName);
-                FileName = GetIOFileName(FilePathName);
+                filePathName = GetLegalPath(filePathName);
+                filePath = GetDirectoryName(filePathName);
+                fileName = GetIoFileName(filePathName);
             }
             catch (Exception)
             {
-                ErrMessage = "路径或文件名不合法！";
+                errMessage = "路径或文件名不合法！";
                 return false;
             }
             Regex regex = new Regex(@"^([a-zA-Z]:\\)?[^\/\:\*\?\""\<\>\|\,]*$");
-            Match m = regex.Match(FilePath);
+            Match m = regex.Match(filePath);
             if (!m.Success)
             {
-                ErrMessage = "非法的文件保存路径！";
+                errMessage = "非法的文件保存路径！";
                 return false;
             }
-            if (!string.IsNullOrWhiteSpace(FileName))
+            if (!string.IsNullOrWhiteSpace(fileName))
             {
                 regex = new Regex(@"^[^\/\:\*\?\""\<\>\|\,]+$");
-                m = regex.Match(FileName);
+                m = regex.Match(fileName);
                 if (!m.Success)
                 {
-                    ErrMessage = "非法的文件名！文件名中包含\\ / : * ？ \" < > |等字符!";
+                    errMessage = "非法的文件名！文件名中包含\\ / : * ？ \" < > |等字符!";
                     return false;
                 }
             }
             return true;
-
         }
+
         #endregion
 
         #region 检测指定目录是否存在
+
         /// <summary>  
         /// 检测指定目录是否存在  
         /// </summary>  
         {
             return Directory.Exists(directoryPath);
         }
+
         #endregion
 
         #region 检测指定文件是否存在
+
         /// <summary>  
         /// 检测指定文件是否存在,如果存在则返回true。  
         /// </summary>  
         {
             return File.Exists(filePath);
         }
+
         #endregion
 
         #region 检测指定目录是否为空
+
         /// <summary>  
         /// 检测指定目录是否为空  
         /// </summary>  
                 return false;
             }
         }
+
         #endregion
 
         #region 检测指定目录中是否存在指定的文件
+
         /// <summary>  
         /// 检测指定目录中是否存在指定的文件,若要搜索子目录请使用重载方法.  
         /// </summary>  
             try
             {
                 //获取指定的文件列表  
-                string[] fileNames = GetFileNames(directoryPath, searchPattern, false);
+                string[] fileNames = GetFileNames
+                (
+                    directoryPath,
+                    searchPattern,
+                    false
+                );
 
                 //判断指定文件是否存在  
                 return fileNames.Length != 0;
         /// <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)
+        public static bool Contains
+        (
+            string directoryPath,
+            string searchPattern,
+            bool isSearchChild
+        )
         {
             try
             {
                 //获取指定的文件列表  
-                string[] fileNames = GetFileNames(directoryPath, searchPattern, isSearchChild);
+                string[] fileNames = GetFileNames
+                (
+                    directoryPath,
+                    searchPattern,
+                    isSearchChild
+                );
 
                 //判断指定文件是否存在  
                 return fileNames.Length != 0;
                 return false;
             }
         }
+
         #endregion
 
         #region 创建一个目录
+
         /// <summary>  
         /// 创建一个目录  
         /// </summary>  
                 throw new ApplicationException(ex.Message); //"请使用管理员权限运行！"
             }
         }
+
         #endregion
 
         #region 创建一个文件
+
         /// <summary>  
         /// 创建一个文件。  
         /// </summary>  
             {
                 return false;
             }
-
             return true;
         }
 
                     FileStream fs = file.Create();
 
                     //写入二进制流  
-                    fs.Write(buffer, 0, buffer.Length);
+                    fs.Write
+                    (
+                        buffer,
+                        0,
+                        buffer.Length
+                    );
 
                     //关闭文件流  
                     fs.Close();
             }
             return true;
         }
+
         #endregion
 
         #region 获取文本文件的行数
+
         /// <summary>  
         /// 获取文本文件的行数  
         /// </summary>  
             //返回行数  
             return rows.Length;
         }
+
         #endregion
 
         #region 获取一个文件的长度
+
         /// <summary>  
         /// 获取一个文件的长度,单位为Byte  
         /// </summary>  
         /// 获取一个文件的长度,单位为KB  
         /// </summary>  
         /// <param name="filePath">文件的路径</param>          
-        public static double GetFileSizeByKB(string filePath)
+        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);
+            double size = Math.Round
+            (
+                (fi.Length / 1024.0),
+                2,
+                MidpointRounding.AwayFromZero
+            );
             //获取文件的大小  
             return size;
         }
         /// 获取一个文件的长度,单位为MB  
         /// </summary>  
         /// <param name="filePath">文件的路径</param>          
-        public static double GetFileSizeByMB(string filePath)
+        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);
+            double size = Math.Round
+            (
+                (fi.Length / 1024.0 / 1024.0),
+                2,
+                MidpointRounding.AwayFromZero
+            );
             //获取文件的大小  
             return size;
         }
+
         #endregion
 
         #region 获取指定目录中的文件列表
+
         /// <summary>  
         /// 获取指定目录中所有文件列表  
         /// </summary>  
             //如果目录不存在，则抛出异常  
             if (!IsExistDirectory(directoryPath))
             {
-                return null;//throw new FileNotFoundException();
+                return null; //throw new FileNotFoundException();
             }
             DirectoryInfo folder = new DirectoryInfo(directoryPath);
             FileInfo[] fileList;
             //如果目录不存在，则抛出异常  
             if (!IsExistDirectory(directoryPath))
             {
-                return null;//throw new FileNotFoundException();
+                return null; //throw new FileNotFoundException();
             }
 
             //获取文件列表  
         /// <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)
+        public static string[] GetFileNames
+        (
+            string directoryPath,
+            string searchPattern,
+            bool isSearchChild
+        )
         {
             //如果目录不存在，则抛出异常  
             if (!IsExistDirectory(directoryPath))
             {
-                return null;//throw new FileNotFoundException();
+                return null; //throw new FileNotFoundException();
             }
-
             try
             {
-                return Directory.GetFiles(directoryPath, searchPattern, isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
+                return Directory.GetFiles
+                (
+                    directoryPath,
+                    searchPattern,
+                    isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly
+                );
             }
             catch
             {
                 return null;
             }
         }
+
         #endregion
 
         #region 获取指定目录中的子目录列表
+
         /// <summary>  
         /// 获取指定目录中所有子目录列表,若要搜索嵌套的子目录列表,请使用重载方法.  
         /// </summary>  
         /// <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)
+        public static string[] GetDirectories
+        (
+            string directoryPath,
+            string searchPattern,
+            bool isSearchChild
+        )
         {
             try
             {
-                return Directory.GetDirectories(directoryPath, searchPattern, isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
+                return Directory.GetDirectories
+                (
+                    directoryPath,
+                    searchPattern,
+                    isSearchChild ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly
+                );
             }
             catch
             {
-                return null;//throw
+                return null; //throw
             }
         }
+
         #endregion
 
         #region 向文本文件写入内容
+
         /// <summary>  
         /// 向文本文件中写入内容  
         /// </summary>  
             //向文件写入内容  
             File.WriteAllText(filePath, content);
         }
+
         #endregion
 
         #region 向文本文件的尾部追加内容
+
         /// <summary>  
         /// 向文本文件的尾部追加内容  
         /// </summary>  
         {
             File.AppendAllText(filePath, content);
         }
+
         #endregion
 
         #region 将现有文件的内容复制到新文件中
+
         /// <summary>  
         /// 将源文件的内容复制到目标文件中  
         /// </summary>  
         /// <param name="destFilePath">目标文件的绝对路径</param>  
         public static void Copy(string sourceFilePath, string destFilePath)
         {
-            File.Copy(sourceFilePath, destFilePath, true);
+            File.Copy
+            (
+                sourceFilePath,
+                destFilePath,
+                true
+            );
         }
+
         #endregion
 
         #region 将文件移动到指定目录
+
         /// <summary>  
         /// 将文件移动到指定目录  
         /// </summary>  
         {
             //获取源文件的名称  
             string sourceFileName = GetFileName(sourceFilePath);
-
             if (IsExistDirectory(descDirectoryPath))
             {
                 //如果目标中存在同名文件,则删除  
                 File.Move(sourceFilePath, descDirectoryPath + "\\" + sourceFileName);
             }
         }
+
         #endregion
 
         #region 将流读取到缓冲区中
+
         /// <summary>  
         /// 将流读取到缓冲区中  
         /// </summary>  
                 byte[] buffer = new byte[stream.Length];
 
                 //读取流  
-                stream.Read(buffer, 0, int.Parse(stream.Length.ToString()));
+                stream.Read
+                (
+                    buffer,
+                    0,
+                    int.Parse(stream.Length.ToString())
+                );
 
                 //返回流  
                 return buffer;
                 stream.Close();
             }
         }
+
         #endregion
 
         #region 将文件读取到缓冲区中
+
         /// <summary>  
         /// 将文件读取到缓冲区中  
         /// </summary>  
             //创建一个文件流  
             FileInfo fi = new FileInfo(filePath);
             FileStream fs = fi.Open(FileMode.Open);
-
             try
             {
                 //将文件流读入缓冲区  
-                fs.Read(buffer, 0, (int)fileSize);
-
+                fs.Read
+                (
+                    buffer,
+                    0,
+                    (int)fileSize
+                );
                 return buffer;
             }
             catch
                 fs.Close();
             }
         }
+
         /// <summary>
         /// 读取大文件用,读取文件前面指定长度字节数
         /// </summary>
         /// <param name="filePath">文件路径</param>
-        /// <param name="Length">读取长度,单位字节</param>
+        /// <param name="length">读取长度,单位字节</param>
         /// <returns></returns>
-        public static byte[] ReadBigFile(string filePath, int Length)
+        public static byte[] ReadBigFile(string filePath, int length)
         {
             FileStream stream = new FileStream(filePath, FileMode.Open);
-            byte[] buffer = new byte[Length];
+            byte[] buffer = new byte[length];
             //stream.Position = startIndex;
-            stream.Read(buffer, 0, Length);
+            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>
+        /// <param name="length">长度</param>
         /// <returns></returns>
-        public static byte[] ReadBigFileSpecifyLength(string filePath, long startIndex, int Length)
+        public static byte[] ReadBigFileSpecifyLength
+        (
+            string filePath,
+            long startIndex,
+            int length
+        )
         {
             FileStream stream = new FileStream(filePath, FileMode.Open);
-            if (startIndex + Length + 1 > stream.Length)
+            if (startIndex + length + 1 > stream.Length)
             {
-                Length = (int)(stream.Length - startIndex);
+                length = (int)(stream.Length - startIndex);
             }
-            byte[] buffer = new byte[Length];
+            byte[] buffer = new byte[length];
             stream.Position = startIndex;
-            stream.Read(buffer, 0, Length);
+            stream.Read
+            (
+                buffer,
+                0,
+                length
+            );
             stream.Close();
             stream.Dispose();
             return buffer;
         }
+
         #endregion
 
         #region 将文件读取到字符串中
+
         /// <summary>  
         /// 将文件读取到字符串中  
         /// </summary>  
             //return FileToString(filePath, Encoding.Default); 
             return FileToString(filePath, Encoding.UTF8);
         }
+
         /// <summary>  
         /// 将文件读取到字符串中  
         /// </summary>  
                 reader.Close();
             }
         }
+
         /// <summary>
         /// 读取大文件用,读取文件前面指定长度字节的字符串
         /// </summary>
         /// <param name="filePath">文件路径</param>
-        /// <param name="Length">读取长度,单位字节</param>
+        /// <param name="length">读取长度,单位字节</param>
         /// <returns></returns>
-        public static string ReadBigFileStr(string filePath, int Length)
+        public static string ReadBigFileStr(string filePath, int length)
         {
-            byte[] buffer = ReadBigFile(filePath, Length);
+            byte[] buffer = ReadBigFile(filePath, length);
             return Encoding.Default.GetString(buffer);
         }
 
         #endregion
 
         #region 从文件的绝对路径中获取文件名( 包含扩展名 )
+
         /// <summary>  
         /// 从文件的绝对路径中获取文件名( 包含扩展名 )  
         /// </summary>  
             FileInfo fi = new FileInfo(filePath);
             return fi.Name;
         }
+
         /// <summary>  
         /// 使用IO从文件的绝对路径中获取文件名( 包含扩展名 )  
         /// </summary>  
         /// <param name="filePath">文件的绝对路径</param>          
-        public static string GetIOFileName(string filePath)
+        public static string GetIoFileName(string filePath)
         {
             return Path.GetFileName(filePath);
         }
+
         #endregion
 
         #region 从文件的绝对路径中获取文件名( 不包含扩展名 )
+
         /// <summary>  
         /// 从文件的绝对路径中获取文件名( 不包含扩展名 )  
         /// </summary>  
             FileInfo fi = new FileInfo(filePath);
             return fi.Name.Split('.')[0];
         }
+
         /// <summary>  
         /// 使用IO从文件的绝对路径中获取文件名( 不包含扩展名 )  
         /// </summary>  
         /// <param name="filePath">文件的绝对路径</param>          
-        public static string GetIOFileNameNoExtension(string filePath)
+        public static string GetIoFileNameNoExtension(string filePath)
         {
             return System.IO.Path.GetFileNameWithoutExtension(filePath);
         }
+
         #endregion
 
         #region 从文件的绝对路径中获取扩展名
+
         /// <summary>  
         /// 从文件的绝对路径中获取扩展名  
         /// </summary>  
             FileInfo fi = new FileInfo(filePath);
             return fi.Extension;
         }
+
         /// <summary>  
         /// 使用IO从文件的绝对路径中获取扩展名 
         /// </summary>  
         /// <param name="filePath">文件的绝对路径</param>          
-        public static string GetIOExtension(string filePath)
+        public static string GetIoExtension(string filePath)
         {
-            string Extension = System.IO.Path.GetExtension(filePath);
-            return Extension;
+            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;
+            string directoryName = (System.IO.Path.GetDirectoryName(filePath) + @"/").Replace("\\", "/");
+            return directoryName;
         }
+
         #endregion
 
         #region 清空指定目录
+
         /// <summary>  
         /// 清空指定目录下所有文件及子目录,但该目录依然保存.  
         /// </summary>  
                 }
             }
         }
+
         #endregion
 
         #region 清空文件内容
+
         /// <summary>  
         /// 清空文件内容  
         /// </summary>  
             //重新创建该文件  
             CreateFile(filePath);
         }
+
         #endregion
 
         #region 删除指定文件
+
         /// <summary>  
         /// 删除指定文件  
         /// </summary>  
             }
             catch (Exception)
             {
-
+                // ignored
             }
         }
+
         #endregion
 
         #region 删除指定目录
+
         /// <summary>  
         /// 删除指定目录及其所有子目录  
         /// </summary>  
                 return false;
             }
         }
+
         #endregion
 
         #region 获取指定目录大小
+
         /// <summary>
         /// 获取目录大小
         /// </summary>
         public static double PathSize(string directoryPath)
         {
             DirectoryInfo folder = new DirectoryInfo(directoryPath);
-            double DirectorySize = DirSize(folder);
+            double directorySize = DirSize(folder);
             for (int i = 0; i < 2; i++)
             {
-                DirectorySize /= 1024;
+                directorySize /= 1024;
             }
-            return DirectorySize;
+            return directorySize;
         }
 
         /// <summary>
         /// <returns>字节</returns>
         public static long DirSize(DirectoryInfo d)
         {
-            long Size = 0;
+            long size = 0;
             // 所有文件大小.
             FileInfo[] fis = d.GetFiles();
             foreach (FileInfo fi in fis)
             {
-                Size += fi.Length;
+                size += fi.Length;
             }
             // 遍历出当前目录的所有文件夹.
             DirectoryInfo[] dis = d.GetDirectories();
             foreach (DirectoryInfo di in dis)
             {
-                Size += DirSize(di);   //这就用到递归了，调用父方法,注意，这里并不是直接返回值，而是调用父返回来的
+                size += DirSize(di); //这就用到递归了，调用父方法,注意，这里并不是直接返回值，而是调用父返回来的
             }
-            return (Size);
+            return (size);
         }
+
         #endregion
 
         #region 移动目录
+
         /// <summary>
         /// 移动目录并重命名
         /// </summary>
         /// <param name="directoryPath">操作目录绝对路径</param>
         /// <param name="newDirectoryPath">目标目录绝对路径</param>
-        /// <param name="Message">返回错误消息，成功则为空</param>
+        /// <param name="message">返回错误消息，成功则为空</param>
         /// <returns></returns>
-        public static bool MoveDirectory(string directoryPath, string newDirectoryPath, out string Message)
+        public static bool MoveDirectory
+        (
+            string directoryPath,
+            string newDirectoryPath,
+            out string message
+        )
         {
-            Message = "";
+            message = "";
             try
             {
-                if (!IsExistDirectory(directoryPath))//判断目录是否存在
+                if (!IsExistDirectory(directoryPath)) //判断目录是否存在
                 {
-                    Message = "操作目录不存在！";
+                    message = "操作目录不存在！";
                     return false;
                 }
                 if (IsExistDirectory(newDirectoryPath))
                 {
-                    Message = "目标目录已存在！";
+                    message = "目标目录已存在！";
                     return false;
                 }
                 Directory.Move(directoryPath, newDirectoryPath);
             }
             catch (Exception ex)
             {
-                Message = ex.Message;
+                message = ex.Message;
                 return false;
             }
         }
+
         #endregion
 
         #region 操作配置文件
+
         #region 从配置文件获取Value
+
         /// <summary>
         /// 从配置文件获取Value
         /// </summary>
                 return "";
             }
         }
+
         #endregion
 
         #region 设置配置文件
+
         /// <summary>
         /// 设置配置文件
         /// </summary>
                 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>  
         /// <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 uninstallNode = Microsoft.Win32.Registry.LocalMachine.OpenSubKey
+            (
+                @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall",
+                Microsoft.Win32.RegistryKeyPermissionCheck.ReadWriteSubTree,
+                System.Security.AccessControl.RegistryRights.ReadKey
+            );
+            if (uninstallNode != null)
             {
-                //Console.WriteLine(" subKeyName:" + subKeyName);
-                Microsoft.Win32.RegistryKey subKey = uninstallNode.OpenSubKey(subKeyName);
-                object displayName = subKey.GetValue("DisplayName");
-                if (displayName != null)
+                foreach (string subKeyName in uninstallNode.GetSubKeyNames())
                 {
-                    if (displayName.ToString().Contains(softWareName))
+                    //Console.WriteLine(" subKeyName:" + subKeyName);
+                    Microsoft.Win32.RegistryKey subKey = uninstallNode.OpenSubKey(subKeyName);
+                    if (subKey != null)
                     {
-                        //Console.WriteLine(uninstallNode.Name+" subKeyName:" + subKeyName);
-                        return true;
-                        // MessageWindow.Show(displayName.ToString());  
+                        object displayName = subKey.GetValue("DisplayName");
+                        if (displayName != null)
+                        {
+                            if (displayName.ToString().Contains(softWareName))
+                            {
+                                //Console.WriteLine(uninstallNode.Name+" subKeyName:" + subKeyName);
+                                return true;
+                                // MessageWindow.Show(displayName.ToString());  
+                            }
+                        }
                     }
                 }
             }
             return false;
         }
+
         #endregion
     }
 }

XHWK.WKTool/system/HttpHelper.cs

 
 namespace Common.system
 {
+    using XHWK.WKTool.system;
+
     /// <summary>
     /// HttpHelper
     /// 创建人：赵耀
             }
         }
     }
-}
+}

XHWK.WKTool/system/ImageHelper.cs

 
 namespace Common.system
 {
+    using XHWK.WKTool.system;
+
     /// <summary>
     /// 图片帮助类 创建人：赵耀 创建时间：2018年11月1日
     /// </summary>
         public string filePathName { get; set; }
         public RenderTargetBitmap bmp { get; set; }
     }
-}
+}

XHWK.WKTool/system/LatticeFileHelper.cs

 
 namespace Common.system
 {
+    using XHWK.WKTool.system;
+
     /// <summary>
     /// 点阵文件制作打印
     /// 创建时间：2020年9月1日
                 else
                 {
                     int num = 0;
-                    while (FileToolsCommon.GetFileSizeByMB(LogName) > 2)
+                    while (FileToolsCommon.GetFileSizeByMb(LogName) > 2)
                     {
                         num++;
                         LogName = LogFilePath + LogFileName + "_" + num + ".log";

XHWK.WKTool/system/LogHelper.cs

 
 namespace Common.system
 {
+    using XHWK.WKTool.system;
+
     public class LogHelper
     {
         public static readonly log4net.ILog loginfo = log4net.LogManager.GetLogger("loginfo");
             }
         }
     }
-}
+}