C#工具类整理

 /// <summary>
 /// 日志类
 /// </summary>
 public class Log
 {
     /// <summary>
     /// 日志等级，0.不输出日志；1.只输出错误信息; 2.输出错误和正常信息; 3.输出错误信息、正常信息和调试信息 
     /// </summary>
     public static int logLevel = 3;

     /// <summary>
     /// 在网站根目录下创建日志目录
     /// </summary>
     public static string path = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory) + Path.DirectorySeparatorChar + "logs";

     /// <summary>
     /// 向日志文件写入调试信息
     /// </summary>
     /// <param name="className">类名</param>
     /// <param name="content">写入内容</param>
     public static void Debug(string className, string content)
     {
         if (logLevel >= 3)
         {
             WriteLog("DEBUG", className, content);
         }
     }

     /// <summary>
     /// 向日志文件写入运行时信息
     /// </summary>
     /// <param name="className">类名</param>
     /// <param name="content">写入内容</param>
     public static void Info(string className, string content)
     {
         if (logLevel >= 2)
         {
             WriteLog("INFO", className, content);
         }
     }

     /// <summary>
     /// 向日志文件写入出错信息
     /// </summary>
     /// <param name="className">类名</param>
     /// <param name="content">写入内容</param>
     public static void Error(string className, string content)
     {
         if (logLevel >= 1)
         {
             WriteLog("ERROR", className, content);
         }
     }

     /// <summary>
     /// 实际的写日志操作
     /// </summary>
     /// <param name="type">日志记录类型</param>
     /// <param name="className">类名</param>
     /// <param name="content">写入内容</param>
     protected static void WriteLog(string type, string className, string content)
     {
         if (!Directory.Exists(path))//如果日志目录不存在就创建
         {
             Directory.CreateDirectory(path);
         }

         string time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff");//获取当前系统时间
         string filename = path + "/" + DateTime.Now.ToString("yyyy-MM-dd") + ".log";//用日期对日志文件命名

         //创建或打开日志文件，向日志文件末尾追加记录
         using (StreamWriter mySw = File.AppendText(filename))
         {
             //向日志文件写入内容
             string write_content = time + " " + type + " " + className + ": " + content;
             mySw.WriteLine(write_content);
         }
     }
 }

 

 /// <summary>
 /// RSA密钥格式转换
 /// </summary>
 public class RSAKeyConvert
 {
     #region 私钥

     /// <summary>
     /// RSA私钥格式转换，java->.net
     /// </summary>
     /// <param name="privateKey">java生成的RSA私钥</param>
     /// <returns></returns>
     public static string RSAPrivateKeyJava2DotNet(string privateKey)
     {
         RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));

         return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent><P>{2}</P><Q>{3}</Q><DP>{4}</DP><DQ>{5}</DQ><InverseQ>{6}</InverseQ><D>{7}</D></RSAKeyValue>",
             Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()),
             Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()),
             Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()),
             Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()),
             Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()),
             Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()),
             Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()),
             Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
     }

     /// <summary>
     /// RSA私钥格式转换，.net->java
     /// </summary>
     /// <param name="privateKey">.net生成的私钥</param>
     /// <returns></returns>
     public static string RSAPrivateKeyDotNet2Java(string privateKey)
     {
         XmlDocument doc = new XmlDocument();
         doc.LoadXml(privateKey);
         BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
         BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
         BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
         BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
         BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
         BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
         BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
         BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));

         RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);

         PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
         byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
         return Convert.ToBase64String(serializedPrivateBytes);
     }

     /// <summary>
     /// PEM私钥转换成XML私钥
     /// </summary>
     /// <param name="privateKey">生成的RSA私钥 pem格式密钥</param>
     /// <returns></returns>
     public static string PrivateKeyPemToXml(string privateKey)
     {
         string rsaKey = string.Empty;
         using (StringReader sReader = new StringReader(privateKey))
         {
             var pemReader = new Org.BouncyCastle.OpenSsl.PemReader(sReader);
             object pemObject = pemReader.ReadObject();

             RsaPrivateCrtKeyParameters key = (RsaPrivateCrtKeyParameters)((AsymmetricCipherKeyPair)pemObject).Private;
             RSAParameters rsaPara = new RSAParameters
             {
                 Modulus = key.Modulus.ToByteArrayUnsigned(),
                 Exponent = key.PublicExponent.ToByteArrayUnsigned(),
                 D = key.Exponent.ToByteArrayUnsigned(),
                 P = key.P.ToByteArrayUnsigned(),
                 Q = key.Q.ToByteArrayUnsigned(),
                 DP = key.DP.ToByteArrayUnsigned(),
                 DQ = key.DQ.ToByteArrayUnsigned(),
                 InverseQ = key.QInv.ToByteArrayUnsigned(),
             };
             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             rsa.ImportParameters(rsaPara);
             using (StringWriter sw = new StringWriter())
             {
                 sw.Write(rsa.ToXmlString(true));
                 rsaKey = sw.ToString();
             }
         }
         return rsaKey;
     }

     /// <summary>
     /// XML私钥转成PEM私钥
     /// </summary>
     /// <param name="xmlPrivateKey"></param>
     /// <returns></returns>
     public static string PrivateKeyXmlToPem(string xmlPrivateKey)
     {
         RSAParameters rsaParam;
         using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
         {
             rsa.FromXmlString(xmlPrivateKey);
             rsaParam = rsa.ExportParameters(true);
         }

         var param = new RsaPrivateCrtKeyParameters(
         new BigInteger(1, rsaParam.Modulus), new BigInteger(1, rsaParam.Exponent), new BigInteger(1, rsaParam.D),
         new BigInteger(1, rsaParam.P), new BigInteger(1, rsaParam.Q), new BigInteger(1, rsaParam.DP), new BigInteger(1, rsaParam.DQ),
         new BigInteger(1, rsaParam.InverseQ));

         string pemPrivateKeyStr = null;
         using (var ms = new MemoryStream())
         {
             using (var sw = new StreamWriter(ms))
             {
                 var pemWriter = new Org.BouncyCastle.OpenSsl.PemWriter(sw);
                 pemWriter.WriteObject(param);
                 sw.Flush();

                 byte[] buffer = new byte[ms.Length];
                 ms.Position = 0;
                 ms.Read(buffer, 0, (int)ms.Length);
                 pemPrivateKeyStr = Encoding.UTF8.GetString(buffer);
             }
         }

         return pemPrivateKeyStr;
     }
     #endregion 私钥

     #region 公钥
     /// <summary>
     /// RSA公钥格式转换，java->.net
     /// </summary>
     /// <param name="publicKey">java生成的公钥</param>
     /// <returns></returns>
     public static string RSAPublicKeyJava2DotNet(string publicKey)
     {
         RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
         return string.Format("<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
             Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
             Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned()));
     }

     /// <summary>
     /// RSA公钥格式转换，.net->java
     /// </summary>
     /// <param name="publicKey">.net生成的公钥</param>
     /// <returns></returns>
     public static string RSAPublicKeyDotNet2Java(string publicKey)
     {
         XmlDocument doc = new XmlDocument();
         doc.LoadXml(publicKey);
         BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
         BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
         RsaKeyParameters pub = new RsaKeyParameters(false, m, p);

         SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub);
         byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
         return Convert.ToBase64String(serializedPublicBytes);
     }

     /// <summary>
     /// PEM公钥转换成XML公钥
     /// </summary>
     /// <param name="publicKey">生成的RSA公钥 pem格式密钥</param>
     /// <returns></returns>
     public static string PublicKeyPemToXml(string publicKey)
     {
         string rsaKey = string.Empty;
         using (StringReader sReader = new StringReader(publicKey))
         {
             var pemReader = new Org.BouncyCastle.OpenSsl.PemReader(sReader);
             object pemObject = pemReader.ReadObject();

             RsaKeyParameters key = (RsaKeyParameters)pemObject;
             RSAParameters rsaPara = new RSAParameters
             {
                 Modulus = key.Modulus.ToByteArrayUnsigned(),
                 Exponent = key.Exponent.ToByteArrayUnsigned(),
             };
             RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
             rsa.ImportParameters(rsaPara);
             using (StringWriter sw = new StringWriter())
             {
                 sw.Write(rsa.ToXmlString(true));
                 rsaKey = sw.ToString();
             }
         }
         return rsaKey;
     }

     /// <summary>
     /// XML公钥转成Pem公钥
     /// </summary>
     /// <param name="xmlPublicKey"></param>
     /// <returns></returns>
     public static string PublicKeyXmlToPem(string xmlPublicKey)
     {
         RSAParameters rsaParam;
         using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
         {
             rsa.FromXmlString(xmlPublicKey);
             rsaParam = rsa.ExportParameters(false);
         }
         RsaKeyParameters param = new RsaKeyParameters(false, new BigInteger(1, rsaParam.Modulus), new BigInteger(1, rsaParam.Exponent));

         string pemPublicKeyStr = null;
         using (var ms = new MemoryStream())
         {
             using (var sw = new StreamWriter(ms))
             {
                 var pemWriter = new Org.BouncyCastle.OpenSsl.PemWriter(sw);
                 pemWriter.WriteObject(param);
                 sw.Flush();

                 byte[] buffer = new byte[ms.Length];
                 ms.Position = 0;
                 ms.Read(buffer, 0, (int)ms.Length);
                 pemPublicKeyStr = Encoding.UTF8.GetString(buffer);
             }
         }

         return pemPublicKeyStr;
     }
     #endregion 公钥

 }

/// <summary>
/// 解密
/// </summary>
/// <param name="privateKey">私钥 “-----BEGIN RSA PRIVATE KEY-----”开头 “-----END RSA PRIVATE KEY-----”结尾</param>
/// <param name="text">使用publickey_ver指定版本的公钥进行非对称加密后base64加密的内容</param>
/// <returns></returns>
public string Decrypt(string privateKey, string text)
{
    var rsa = new RSACryptoServiceProvider();
    var bytes = Convert.FromBase64String(text);
    rsa.FromXmlString(RSAKeyConvert.PrivateKeyPemToXml(privateKey));
    var result = rsa.Decrypt(bytes, false);
    return Encoding.UTF8.GetString(result);
}

 

/// <summary>
/// 缓存工具类
/// </summary>
public class CacheHelper
{
    /// <summary>
    /// 获取数据缓存
    /// </summary>
    /// <param name="CacheKey">对象的键值</param>
    public static object GetCache(string CacheKey)
    {
        Cache objCache = HttpRuntime.Cache;
        return objCache[CacheKey];
    }

    /// <summary>
    /// 设置数据缓存
    /// </summary>
    /// <param name="CacheKey">对象的键值</param>
    /// <param name="obj">缓存的对象</param>
    public static void SetCache(string CacheKey, object obj)
    {
        Cache objCache = HttpRuntime.Cache;
        objCache.Insert(CacheKey, obj);
    }

    /// <summary>
    /// 设置数据缓存
    /// </summary>
    /// <param name="CacheKey">对象的键值</param>
    /// <param name="obj">缓存的对象</param>
    /// <param name="Timeout"></param>
    public static void SetCache(string CacheKey, object obj, TimeSpan Timeout)
    {
        Cache objCache = HttpRuntime.Cache;
        objCache.Insert(CacheKey, obj, null, DateTime.MaxValue, Timeout, CacheItemPriority.NotRemovable, null);
    }

    /// <summary>
    /// 设置数据缓存
    /// </summary>
    /// <param name="CacheKey">对象的键值</param>
    /// <param name="obj">缓存的对象</param>
    /// <param name="expire"></param>
    public static void SetCache(string CacheKey, object obj, int expire)
    {
        Cache objCache = HttpRuntime.Cache;
        //表示永不过期
        if (expire == 0)
        {
            objCache.Insert(CacheKey, obj, null, DateTime.MaxValue, TimeSpan.Zero, CacheItemPriority.High, null);
        }
        else
        {
            objCache.Insert(CacheKey, obj, null, DateTime.Now.AddSeconds(expire), Cache.NoSlidingExpiration, CacheItemPriority.High, null);
        }
    }

    /// <summary>
    /// 设置数据缓存
    /// </summary>
    /// <param name="CacheKey">对象的键值</param>
    /// <param name="obj">缓存的对象</param>
    /// <param name="absoluteExpiration"></param>
    /// <param name="slidingExpiration"></param>
    public static void SetCache(string CacheKey, object obj, DateTime absoluteExpiration, TimeSpan slidingExpiration)
    {
        Cache objCache = HttpRuntime.Cache;
        objCache.Insert(CacheKey, obj, null, absoluteExpiration, slidingExpiration);
    }

    /// <summary>
    /// 移除指定数据缓存
    /// </summary>
    /// <param name="CacheKey">对象的键值</param>
    public static void RemoveCache(string CacheKey)
    {
        Cache _cache = HttpRuntime.Cache;
        _cache.Remove(CacheKey);
    }

    /// <summary>
    /// 移除全部缓存
    /// </summary>
    public static void RemoveAllCache()
    {
        Cache _cache = HttpRuntime.Cache;
        IDictionaryEnumerator CacheEnum = _cache.GetEnumerator();
        while (CacheEnum.MoveNext())
        {
            _cache.Remove(CacheEnum.Key.ToString());
        }
    }

    /// <summary>
    /// 获取所有缓存
    /// </summary>
    /// <returns></returns>
    public static List<DictionaryEntry> GetAllCache()
    {
        List<DictionaryEntry> list = new List<DictionaryEntry>();
        Cache _cache = HttpRuntime.Cache;
        IDictionaryEnumerator CacheEnum = _cache.GetEnumerator();
        while (CacheEnum.MoveNext())
        {
            list.Add((DictionaryEntry)CacheEnum.Current);
            //cacheItem = Server.HtmlEncode(CacheEnum.Current.ToString());
            //Response.Write(cacheItem);
        }
        return list;
    }
}

 /// <summary>
 /// 时间类
 /// </summary>
 public static class TimeHelper
 {
     /// <summary>
     /// 
     /// </summary>
     private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

     /// <summary>
     /// 将时间转为10位和13位时间戳
     /// </summary>
     /// <param name="dt">时间</param>
     /// <param name="bflag">为真时获取10位时间戳,为假时获取13位时间戳.bool bflag = true</param>
     /// <returns></returns>
     public static long GetDateTimeToUnixTime(DateTime dt, bool bflag = true)
     {
         var utcTime = dt.ToUniversalTime();
         var elapsedTime = utcTime - UnixEpoch;
         if (bflag)
         {
             return (long)elapsedTime.TotalSeconds;
         }
         else
         {
             return (long)elapsedTime.TotalMilliseconds;
         }
     }

     /// <summary>
     /// 将10位和13位时间戳转为时间
     /// </summary>
     /// <param name="unixTime">10位或13位时间戳</param>
     /// <returns></returns>
     public static DateTime GetUnixTimeToDateTime(string unixTime)
     {
         DateTime utcTime;
         long lTime = long.Parse(unixTime);
         if (unixTime.Length == 10)//判断是10位
         {
             utcTime = UnixEpoch.AddSeconds(lTime);
         }
         else if (unixTime.Length == 13)//判断是13位
         {
             utcTime = UnixEpoch.AddMilliseconds(lTime);
         }
         else
         {
             utcTime = UnixEpoch;
         }
         return utcTime.ToLocalTime(); ;

     }
 }