时间处理

public static class DateTimeHelper
    {
    
    
        /// <summary>
        /// 获取当前时间戳（Unix时间戳）  
        /// </summary>
        /// <returns></returns>
        public static long GetCurrentUnixTimestamp()
        {
    
    
            DateTimeOffset offset = DateTimeOffset.UtcNow;
            return Convert.ToInt64((offset - new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero)).TotalSeconds);
        }

        /// <summary>
        /// 将Unix时间戳转换为DateTime 
        /// </summary>
        /// <param name="unixTimestamp"></param>
        /// <returns></returns>
        public static DateTime UnixTimestampToDateTime(long unixTimestamp)
        {
    
    
            DateTime dateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);
            dateTime = dateTime.AddSeconds(unixTimestamp).ToLocalTime();
            return dateTime;
        }

        /// <summary>
        /// 获取当前日期  
        /// </summary>
        /// <returns></returns>
        public static DateTime GetCurrentDate()
        {
    
    
            return DateTime.Now;
        }


        /// <summary>
        /// 格式化日期时间字符串 
        /// </summary>
        /// <param name="dateTime"></param>
        /// <param name="format"></param>
        /// <returns></returns>
        public static string FormatDateTime(DateTime dateTime, string format = "yyyy-MM-dd HH:mm:ss")
        {
    
    
            return dateTime.ToString(format);
        }


        /// <summary>
        /// 获取与当前日期相差多少天
        /// </summary>
        /// <param name="otherTime"></param>
        /// <returns></returns>
        public static double GetDaysDifference(DateTime otherTime)
        {
    
     
            DateTime currentTime = DateTime.Now; 
            TimeSpan timeSpan = currentTime.Subtract(otherTime); 
            double daysDifference = timeSpan.TotalDays; 
            return daysDifference;
        }
    }

文件处理

 /// <summary>
    /// File  操作
    /// </summary>
    public class FileHelper
    {
    
     
        /// <summary>
        /// 从文件中读取文本 
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static string ReadTextFromFile(string filePath) 
        {
    
     
            if (!FileExists(filePath)) 
            {
    
    
                return "";
            } 
            return File.ReadAllText(filePath);
        }

        /// <summary>
        /// 以每行作为界限读取
        /// </summary>
        /// <param name="filePath"></param>
        public static List<string> ReadLineByLineWithFileReadLines(string filePath)
        {
    
    
            return File.ReadLines(filePath).ToList();
        }

        /// <summary>
        /// 写入文本
        /// </summary>
        /// <param name="text"></param>
        /// <param name="filePath"></param>
        public static void WriteTextToFile(string filePath, string text)
        {
    
    
            File.WriteAllText(filePath, text);
        }

        /// <summary>
        /// 追加文本到文件  
        /// </summary>
        /// <param name="text"></param>
        /// <param name="filePath"></param>
        public static void AppendTextToFile(string filePath, string text)
        {
    
     
            File.AppendAllText(filePath, text);
        }

        /// <summary>
        /// 换行追加文本
        /// </summary>
        /// <param name="text"></param>
        /// <param name="filePath"></param>
        public static void AppendTextByLineToFile(string filePath, string text)
        {
    
    
            File.AppendAllText(filePath, Environment.NewLine + text);
        }


        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="filePath"></param>
        public static void DeleteFile(string filePath)
        {
    
    
            File.Delete(filePath);
        }

        /// <summary>
        /// 检查文件是否存在  
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static bool FileExists(string filePath) 
        {
    
     
            return File.Exists(filePath); 
        }

        /// <summary>
        /// 检查文件夹是否存在
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static bool DirectoryExists(string path)
        {
    
    
            return Directory.Exists(path);
        }

        /// <summary>
        /// 创建文件夹
        /// </summary>
        /// <param name="path"></param>
        public static void CreateDirectory(string path)
        {
    
    
            Directory.CreateDirectory(path);
        } 


    }

JSON处理

// Newtonsoft.Json
	/// <summary>
    ///  JSON 处理
    /// </summary>
    public static class JsonHelper
    {
    
    
        /// <summary>
        /// 序列化对象到 JSON 字符串  
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string SerializeObject(object obj)
        {
    
    
            return JsonConvert.SerializeObject(obj);
        }

        /// <summary>
        /// 反序列化 JSON 字符串到对象  
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="json"></param>
        /// <returns></returns>
        public static T DeserializeObject<T>(string json)
        {
    
    
            return JsonConvert.DeserializeObject<T>(json);
        }

        /// <summary>
        /// 序列化对象到格式化（缩进）的 JSON 字符串 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string SerializeObjectIndented(object obj)
        {
    
    
            return JsonConvert.SerializeObject(obj, Formatting.Indented);
        }


        /// <summary>
        /// 将对象序列化为 JSON 并保存到文件
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="filePath"></param>
        public static void SerializeObjectToFile(object obj, string filePath)
        {
    
    
            File.WriteAllText(filePath, SerializeObject(obj));
        }

        /// <summary>
        /// 从文件读取 JSON 并反序列化为对象  
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public static T DeserializeObjectFromFile<T>(string filePath)
        {
    
    
            string json = File.ReadAllText(filePath);
            return DeserializeObject<T>(json);
        }
    }

字符串处理

public static class StringHelper
    {
    
    
        /// <summary>
        /// 转换为大写
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string ToUpperCase(string input)
        {
    
    
            return input.ToUpper();
        }


        /// <summary>
        /// 转换为小写  
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string ToLowerCase(string input)
        {
    
    
            return input.ToLower();
        }


        /// <summary>
        /// 去除字符串两端的空白字符
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string TrimString(string input)
        {
    
    
            return input.Trim();
        }


        /// <summary>
        /// 格式化字符串（使用string.Format的简化版） 
        /// </summary>
        /// <param name="format"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public static string FormatString(string format, params object[] args)
        {
    
    
            return string.Format(format, args);
        }


        /// <summary>
        /// 将字符串转换为字节数组
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static byte[] StringToByteArray(string input)
        {
    
    
            return Encoding.UTF8.GetBytes(input);
        }


        /// <summary>
        /// 将字节数组转换为字符串 
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static string ByteArrayToString(byte[] bytes)
        {
    
    
            return Encoding.UTF8.GetString(bytes);
        }





        /// <summary>
        ///  MD5加密方法  
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string GetMD5Hash(string input)
        {
    
    
            using (MD5 md5Hash = MD5.Create())
            {
    
    
                byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(input));
                StringBuilder sBuilder = new StringBuilder();
                for (int i = 0; i < data.Length; i++)
                {
    
    
                    sBuilder.Append(data[i].ToString("x2"));
                }
                return sBuilder.ToString();
            }
        }


        /// <summary>
        /// 判断当前字符串与MD5加密后的字符串是否一致的方法
        /// </summary>
        /// <param name="input"></param>
        /// <param name="storedHash"></param>
        /// <returns></returns>
        public static bool IsMD5HashMatch(string input, string storedHash)
        {
    
    
            string computedHash = GetMD5Hash(input);
            return computedHash.Equals(storedHash, StringComparison.OrdinalIgnoreCase);
        }


        /// <summary>
        /// 判断字符串是否包含大小写字母和数字，且长度大于7 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static bool IsValidString(string input)
        {
    
    
            if (input == null || input.Length <= 7)
            {
    
    
                return false;
            }
            bool hasUpper = input.Any(char.IsUpper);
            bool hasLower = input.Any(char.IsLower);
            bool hasDigit = input.Any(char.IsDigit);
            return hasUpper && hasLower && hasDigit;
        }



        /// <summary>
        /// 判断字符串是否为url
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static bool IsValidUrl(string url)
        {
    
    
            // 如果字符串为空或只包含空白字符，则返回false  
            if (string.IsNullOrWhiteSpace(url))
            {
    
    
                return false;
            }

            Regex UrlRegex = new Regex(
        @"^http://(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}):(\d{1,5})$",
        RegexOptions.IgnoreCase);

            return UrlRegex.IsMatch(url);
        }


        private static readonly Regex UrlRegex = new Regex(
       @"^(http(?:s)?://)?(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))(?::\d+)?(/[\w ./-]*)?$");
        /// <summary>
        /// 判断字符串是否为url
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static bool IsPossibleUrlWithIpAndPort(string url)
        {
    
     
            return UrlRegex.IsMatch(url);
        }


        private static readonly Regex Ipv4Regex = new Regex(
            @"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
        );
        /// <summary>
        /// 匹配IPv4地址  
        /// </summary>
        /// <param name="ip"></param>
        /// <returns></returns>
        public static bool IsValidIPv4(string ip)
        {
    
     
            return Ipv4Regex.IsMatch(ip);
        }


    }

简易日志处理

public enum LogLevel
    {
    
    
        Log,
        Debug,
        Info,
        Warn,
        Error
    }

    public class SimpleLogger
    {
    
    
        private static string _baseLogPath;
        private static string _currentDateFolder;
        private static string logs = "Logs";


        private static string GetTodayDateString()
        {
    
    
            return DateTime.Now.ToString("yyyyMMdd");
        } 
        private static void CreateLogFolderIfNotExists()
        {
    
    
            string fullPath = System.IO.Path.Combine(_baseLogPath, _currentDateFolder);
            if (!System.IO.Directory.Exists(fullPath))
            {
    
    
                System.IO.Directory.CreateDirectory(fullPath);
            }
        }

        /// <summary>
        /// 写日志
        /// </summary>
        /// <param name="logLevel"></param>
        /// <param name="message"></param>
        public static void WriteLog(LogLevel logLevel, string message)
        {
    
     
            string debugPath = AppDomain.CurrentDomain.BaseDirectory; // 写入文件夹路径
            string logPath = System.IO.Path.Combine(debugPath, logs);
            _baseLogPath = logPath;
            _currentDateFolder = GetTodayDateString();
            CreateLogFolderIfNotExists();
             
            string logFileName = $"{
      
      logLevel.ToString().ToLower()}_{
      
      _currentDateFolder}.log";
            string fullPath = System.IO.Path.Combine(_baseLogPath, _currentDateFolder, logFileName);

            using (System.IO.StreamWriter sw = System.IO.File.AppendText(fullPath))
            {
    
    
                sw.WriteLine($"{
      
      DateTime.Now}: [{
      
      logLevel.ToString()}] {
      
      message}");
            }
        }
    }

C# 获取当前登录的用户及组

DLL

try
{
    
    
    // QA 质量监督人员   MA 维护人员   OP 操作员  AU 高级用户  ADMIN 管理员
    var pessm = new List<string>() {
    
     "QA", "MA", "OP", "AU", "ADMIN"  };
    var pessm2 = new Dictionary<string, string>();
    pessm2.Add("QA", "质量监督人员");
    pessm2.Add("MA", "维护人员");
    pessm2.Add("OP", "操作员");
    pessm2.Add("AU", "高级用户");
    pessm2.Add("ADMIN", "管理员"); 
    ObtainTheInformationOfTheWinDomain.Helper.GetUserGrounp((detail) => {
    
    
    	  string name = detail["name"]; // 用户名称
          string temp = pessm.Where((x) => detail["qx"] == x).First(); // 所在组
    }, pessm);
}catch (Exception ex)
{
    
    
    // ("获取本机用户及组信息错误：" + ex.Message);
}

C# 判断 IP 是否可通讯

        /// <summary>
        /// 判断ip是否通讯
        /// </summary>
        /// <param name="ipAddress"></param>
        /// <returns></returns>
        public static bool CanPingIp()
        {
    
     
            List<string> hsotport = ExtractIpAndPortFromUrl("http://199.1.1.1:8080/api");
            var pinger = new Ping();
            try
            {
    
    
                PingReply reply = pinger.Send(hsotport[0]);
                return reply.Status == IPStatus.Success;
            }
            catch
            {
    
    
                return false;
            }
        }
        /// <summary>
        /// 获取ip 端口
        /// </summary> 
        public static List<string> ExtractIpAndPortFromUrl(string url)
        {
    
    
            Uri uri = new Uri(url);
            string host = uri.Host; // 获取主机名（IP地址或域名）  
            int port = uri.Port; // 获取端口号，如果没有指定端口，默认为80  

            // 如果端口是默认的HTTP端口（80）或HTTPS端口（443），并且URL中没有显式指定端口，则返回-1  
            if ((uri.Scheme == Uri.UriSchemeHttp && port == 80) || (uri.Scheme == Uri.UriSchemeHttps && port == 443))
            {
    
    
                port = -1; // 表示端口未显式指定  
            }

            return new List<string>() {
    
     host, port.ToString() };
        }