自制常用工具类Common

2025年3月8日 更新

using System;
using System.IO;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Web;
using System.Drawing;
using System.Drawing.Imaging;
using Newtonsoft.Json;
using System.Net.Http;

 

public class Common
{
    /// <summary>
    /// 系统配置文件
    /// </summary>
    public static Config.SystemManageConfig SystemManageConfig { get; set; } = null;

    /// <summary>
    /// 加载
    /// </summary>
    public static void Init()
    {
        #region 系统配置文件
        {
            var SMP = HttpContext.Current.Server.MapPath("/Config/SystemManageConfig.json");
            if (File.Exists(SMP))
                SystemManageConfig = JsonConvert.DeserializeObject<Config.SystemManageConfig>(File.ReadAllText(SMP));
        }
        #endregion
    }

    /// <summary>
    /// 生成随机字母字符串(数字字母混和)
    /// </summary>
    /// <param name="codeCount">待生成的位数</param>
    public static string GetCheckCode(int codeCount)
    {
        string str = string.Empty;
        int rep = 0;
        long num2 = DateTime.Now.Ticks + rep;
        rep++;
        Random random = new Random(((int)(((ulong)num2) & 0xffffffffL)) | ((int)(num2 >> rep)));
        for (int i = 0; i < codeCount; i++)
        {
            char ch;
            int num = random.Next();
            if ((num % 2) == 0)
            {
                ch = (char)(0x30 + ((ushort)(num % 10)));
            }
            else
            {
                ch = (char)(0x41 + ((ushort)(num % 0x1a)));
            }
            str = str + ch.ToString();
        }
        return str;
    }
    /// <summary>
    /// string获取枚举
    /// </summary>
    /// <typeparam name="T">枚举集合</typeparam>
    /// <param name="str"></param>
    /// <returns></returns>
    public static T StringToEnum<T>(string str)
    {
        foreach (var myCode in Enum.GetValues(typeof(T)))
        {
            if (myCode.ToString() == str)
            {
                return (T)myCode;
            }
        }
        throw new ArgumentException(string.Format("{0} 未能找到对应的枚举.", str), "Description");
    }
    /// <summary>
    /// int获取枚举
    /// </summary>
    /// <typeparam name="T">枚举集合</typeparam>
    /// <param name="num"></param>
    /// <returns></returns>
    public static T NumToEnum<T>(int num)
    {
        foreach (var myCode in Enum.GetValues(typeof(T)))
        {
            if ((int)myCode == num)
            {
                return (T)myCode;
            }
        }
        throw new ArgumentException(string.Format("{0} 未能找到对应的枚举.", num), "Description");
    }
    /// <summary>
    /// int获取枚举
    /// </summary>
    /// <typeparam name="T">枚举集合</typeparam>
    /// <param name="num"></param>
    /// <returns></returns>
    public static T NumToEnum<T>(string str)
    {
        int num = 0;
        int.TryParse(str, out num);
        foreach (var myCode in Enum.GetValues(typeof(T)))
        {
            if ((int)myCode == num)
            {
                return (T)myCode;
            }
        }
        throw new ArgumentException(string.Format("{0} 未能找到对应的枚举.", num), "Description");
    }

    #region 获取请求参数

    private static string _RequestParameters(string key, dynamic parameters = null)
    {
        object value = null;
        var contentType = HttpContext.Current.Request.ContentType;
        switch (contentType.Split(';')[0])
        {
            case "application/json":
                {
                    if (parameters != null)
                    {
                        var obj = parameters[key];
                        if (obj != null)
                        {
                            value = obj.Value;
                        }
                    }
                    else
                    {
                        HttpContext.Current.Request.InputStream.Position = 0;
                        StreamReader reader = new StreamReader(HttpContext.Current.Request.InputStream);
                        var json = HttpUtility.UrlDecode(reader.ReadToEnd());
                        var data = JsonConvert.DeserializeObject<dynamic>(json);
                        if (data[key] != null)
                        {
                            value = data[key].Value;
                        }
                    }
                }
                break;
            case "application/x-www-form-urlencoded":
                {
                    var req = HttpContext.Current.Request[key];
                    if (req != null)
                    {
                        value = req.ToString();
                    }
                    else  //尝试参数是否为json格式
                    {
                        try
                        {
                            var json = HttpUtility.UrlDecode(HttpContext.Current.Request.Form.ToString());
                            var data = JsonConvert.DeserializeObject<dynamic>(json);
                            if (data[key] != null)
                            {
                                value = data[key].Value;
                            }
                        }
                        catch (Exception ex)
                        {

                        }
                    }
                }
                break;
            case "multipart/form-data":
                {
                    var req = HttpContext.Current.Request[key];
                    if (req != null)
                    {
                        value = req.ToString();
                    }
                }
                break;
            default:
                break;
        }
        return ObjectToString(value);
    }

    /// <summary>
    /// Request获取String
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>        
    public static string RequestToString(string key, dynamic parameters = null)
    {
        var value = _RequestParameters(key, parameters);
        return value;
    }
    //public static string RequestToString(string key, string defaultstr = "")
    //{
    //    return ObjectToString(HttpContext.Current.Request[key], defaultstr);
    //}

    /// <summary>
    /// Request获取Int
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static int RequestToInt(string key, int mr = -1, dynamic parameters = null)
    {
        var value = _RequestParameters(key, parameters);
        return ObjectToInt(value, mr);
    }
    /// <summary>
    /// Request获取Int
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static int? RequestToInt2(string key, int? mr = null, dynamic parameters = null)
    {
        var value = _RequestParameters(key, parameters);
        return ObjectToInt2(value, mr);
    }
    /// <summary>
    /// Request获取Int
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static int? RequestToIntDefaultNull(string key, int mr = -1, dynamic parameters = null)
    {
        if (string.IsNullOrWhiteSpace(key)) return null;
        var value = _RequestParameters(key, parameters);
        return ObjectToInt(value, mr);
    }


    /// <summary>
    /// Request获取Decimal
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static Decimal RequestToDecimal(string key, decimal mr = 0, dynamic parameters = null)
    {
        var value = _RequestParameters(key, parameters);
        return ObjectToDecimal(value, mr);
    }
    /// <summary>
    /// Request获取DateTime
    /// </summary>
    /// <param name="key"></param>
    /// <param name="buf">是否默认当前时间    默认:1970-01-01</param>
    /// <returns></returns>
    public static DateTime RequestToDateTime(string key, bool buf = false, dynamic parameters = null)
    {
        var value = _RequestParameters(key, parameters);
        return ObjectToDateTime(value, buf);
    }

    /// <summary>
    /// Request获取DateTime
    /// </summary>
    /// <param name="key"></param>
    /// <param name="buf">是否默认当前时间    默认:NULL</param>
    /// <returns></returns>
    public static DateTime? RequestToDateTimeDefaultNull(string key, bool buf = false, dynamic parameters = null)
    {
        var value = _RequestParameters(key, parameters);
        if (string.IsNullOrWhiteSpace(value)) return null;
        return ObjectToDateTime(value, buf);
    }

    /// <summary>
    /// Request获取Boolen
    /// </summary>
    /// <param name="key"></param>
    /// <param name="buf">是否默认当前时间    默认:1970-01-01</param>
    /// <returns></returns>
    public static bool RequestToBool(string key, dynamic parameters = null)
    {
        var value = _RequestParameters(key, parameters);
        return ObjectToBool(value);
    }

    #endregion

    /// <summary>
    /// Object转换String
    /// </summary>
    /// <param name="session"></param>
    /// <returns></returns>
    public static string ObjectToString(object session)
    {
        return session == null ? "" : session.ToString().Trim();
    }
    public static string ObjectToString(object session, string defaultstr = "")
    {
        return session == null ? defaultstr : session.ToString().Trim();
    }
    /// <summary>
    /// Object转换Int
    /// </summary>
    /// <param name="session"></param>
    /// <returns></returns>
    public static int ObjectToInt(object session, int mr = -1)
    {
        int num = mr;
        if (session == null) return num;
        int.TryParse(session.ToString(), out num);
        return num;
    }
    /// <summary>
    /// Object转换Int
    /// </summary>
    /// <param name="session"></param>
    /// <returns></returns>
    public static int? ObjectToInt2(object session, int? mr = null)
    {
        int? num = mr;
        if (session == null) return num;
        int num2;
        if (int.TryParse(session.ToString(), out num2))
            return num2;
        else
            return null;

    }
    /// <summary>
    /// Object转换Decimal
    /// </summary>
    /// <param name="session"></param>
    /// <returns></returns>
    public static decimal ObjectToDecimal(object session, decimal mr = 0)
    {
        decimal num = mr;
        decimal.TryParse(session == null ? "" : session.ToString(), out num);
        return num;
    }
    /// <summary>
    /// Object转换DateTime 时间格式转换 时间格式错误|默认1970-01-01
    /// </summary>
    /// <param name="session"></param>
    /// <param name="buf">是否默认当前时间</param>
    /// <returns></returns>
    public static DateTime ObjectToDateTime(object session, bool buf = false)
    {
        DateTime num = DateTime.Parse("1970-01-01");
        if (!DateTime.TryParse(session == null ? null : session.ToString(), out num))
        {
            if (buf) num = DateTime.Now;
            else num = DateTime.Parse("1970-01-01");
        }
        return num;
    }
    /// <summary>
    /// Object转换Bool
    /// </summary>
    /// <param name="session"></param>
    /// <returns></returns>
    public static bool ObjectToBool(object session)
    {
        bool buf = false;
        bool.TryParse(session == null ? "" : session.ToString(), out buf);
        if (session != null && session.ToString() == "1") buf = true;
        else if (session != null && session.ToString() == "on") buf = true;
        return buf;
    }




    /// <summary>
    /// 获取ip
    /// </summary>
    /// <param name="context"></param>
    /// <returns></returns>
    public static async Task<string> GetIP()
    {
        string result = "";
        HttpClient client = new HttpClient();
        try
        {
            result = await client.GetStringAsync("https://ipv4.icanhazip.com/");
            result = result.Replace("\n", "");
        }
        catch (Exception ex)
        {
            result = HttpContext.Current.Request.ServerVariables["REMOTE_ADDR"];
            if (string.IsNullOrEmpty(result))
                result = HttpContext.Current.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
            if (string.IsNullOrEmpty(result))
                result = HttpContext.Current.Request.UserHostAddress;
            if (string.IsNullOrEmpty(result) || !IsIP(result))
                return "127.0.0.1";
        }
        return result;
    }

    #region 检查是否为IP地址
    /// <summary>
    /// 是否为ip
    /// </summary>
    /// <param name="ip"></param>
    /// <returns></returns>
    public static bool IsIP(string ip)
    {
        return Regex.IsMatch(ip, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$");
    }
    #endregion

    /// <summary>
    /// 获取大写的MD5签名结果
    /// </summary>
    /// <param name="encypStr"></param>
    /// <param name="charset"></param>
    /// <returns></returns>
    public static string GetMD5(string encypStr, string charset)
    {
        string retStr;
        MD5CryptoServiceProvider m5 = new MD5CryptoServiceProvider();

        //创建md5对象
        byte[] inputBye;
        byte[] outputBye;

        //使用GB2312编码方式把字符串转化为字节数组．
        try
        {
            inputBye = Encoding.GetEncoding(charset).GetBytes(encypStr);
        }
        catch (Exception ex)
        {
            inputBye = Encoding.GetEncoding("GB2312").GetBytes(encypStr);
        }
        outputBye = m5.ComputeHash(inputBye);
        m5.Clear();
        retStr = System.BitConverter.ToString(outputBye);
        retStr = retStr.Replace("-", "").ToLower();
        return retStr;
    }

    public static string md5(string str)
    {
        try
        {
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            byte[] bytValue, bytHash;
            bytValue = System.Text.Encoding.UTF8.GetBytes(str);
            bytHash = md5.ComputeHash(bytValue);
            md5.Clear();
            string sTemp = "";
            for (int i = 0; i < bytHash.Length; i++)
            {
                sTemp += bytHash[i].ToString("X").PadLeft(2, '0');
            }
            str = sTemp.ToLower();
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }

        return str;
    }
    /// <summary>
    /// Get 提交
    /// </summary>
    /// <param name="Url"></param>
    /// <param name="postDataStr"></param>
    /// <param name="contentType"></param>
    /// <returns></returns>
    public static string HttpGet(string Url, string postDataStr = "", string contentType = "application/x-www-form-urlencoded")
    {
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
        request.Method = "Get";
        request.Timeout = 20000;
        request.UserAgent = "User-Agent:Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.202 Safari/535.1";
        HttpWebResponse myResponse = (HttpWebResponse)request.GetResponse();
        Stream newStream = myResponse.GetResponseStream();
        StreamReader reader = new StreamReader(newStream, Encoding.UTF8);
        var res = reader.ReadToEnd();
        return res;
    }
    /// <summary>
    /// Post 提交
    /// </summary>
    /// <param name="Url"></param>
    /// <param name="postDataStr"></param>
    /// <param name="contentType"></param>
    /// <returns></returns>
    public static string HttpPost(string Url, string postDataStr, string contentType = "application/x-www-form-urlencoded")
    {
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
        request.Method = "POST";
        request.Timeout = 20000;
        request.KeepAlive = true;
        request.ContentType = contentType;
        request.UserAgent = "User-Agent:Mozilla/5.0 (Windows NT 5.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.202 Safari/535.1";
        byte[] postData = System.Text.Encoding.GetEncoding("utf-8").GetBytes(postDataStr);
        request.ContentLength = postData.Length;
        Stream myRequestStream = request.GetRequestStream();
        myRequestStream.Write(postData, 0, postData.Length);
        myRequestStream.Close();
        return "";
    }

    /// <summary>
    /// DES加密/解密类。
    /// </summary>
    public class DESHelper
    {

        #region ========加密========

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="Text"></param>
        /// <returns></returns>
        public static string Encrypt(string Text)
        {
            return Encrypt(Text, "DTcms");
        }
        /// <summary> 
        /// 加密数据 
        /// </summary> 
        /// <param name="Text"></param> 
        /// <param name="sKey"></param> 
        /// <returns></returns> 
        public static string Encrypt(string Text, string sKey)
        {
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            byte[] inputByteArray;
            inputByteArray = Encoding.Default.GetBytes(Text);
            des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
            cs.Write(inputByteArray, 0, inputByteArray.Length);
            cs.FlushFinalBlock();
            StringBuilder ret = new StringBuilder();
            foreach (byte b in ms.ToArray())
            {
                ret.AppendFormat("{0:X2}", b);
            }
            return ret.ToString();
        }

        #endregion

        #region ========解密========

        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="Text"></param>
        /// <returns></returns>
        public static string Decrypt(string Text)
        {
            return Decrypt(Text, "DTcms");
        }
        /// <summary> 
        /// 解密数据 
        /// </summary> 
        /// <param name="Text"></param> 
        /// <param name="sKey"></param> 
        /// <returns></returns> 
        public static string Decrypt(string Text, string sKey)
        {
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            int len;
            len = Text.Length / 2;
            byte[] inputByteArray = new byte[len];
            int x, i;
            for (x = 0; x < len; x++)
            {
                i = Convert.ToInt32(Text.Substring(x * 2, 2), 16);
                inputByteArray[x] = (byte)i;
            }
            des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
            cs.Write(inputByteArray, 0, inputByteArray.Length);
            cs.FlushFinalBlock();
            return Encoding.Default.GetString(ms.ToArray());
        }

        #endregion

    }


    public class AESHelper
    {
        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="Data">被加密的明文</param>
        /// <param name="Key">密钥</param>
        /// <param name="Vector">向量</param>
        /// <returns>密文</returns>
        public static String AESEncrypt(String Data, String Key, String Vector)
        {
            Byte[] plainBytes = Encoding.UTF8.GetBytes(Data);

            Byte[] bKey = new Byte[32];
            Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
            Byte[] bVector = new Byte[16];
            Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);

            Byte[] Cryptograph = null; // 加密后的密文

            Rijndael Aes = Rijndael.Create();
            try
            {
                // 开辟一块内存流
                using (MemoryStream Memory = new MemoryStream())
                {
                    // 把内存流对象包装成加密流对象
                    using (CryptoStream Encryptor = new CryptoStream(Memory,
                     Aes.CreateEncryptor(bKey, bVector),
                     CryptoStreamMode.Write))
                    {
                        // 明文数据写入加密流
                        Encryptor.Write(plainBytes, 0, plainBytes.Length);
                        Encryptor.FlushFinalBlock();

                        Cryptograph = Memory.ToArray();
                    }
                }
            }
            catch
            {
                Cryptograph = null;
            }

            return Convert.ToBase64String(Cryptograph);
        }

        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="Data">被解密的密文</param>
        /// <param name="Key">密钥</param>
        /// <param name="Vector">向量</param>
        /// <returns>明文</returns>
        public static String AESDecrypt(String Data, String Key, String Vector)
        {
            Byte[] encryptedBytes = Convert.FromBase64String(Data);
            Byte[] bKey = new Byte[32];
            Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
            Byte[] bVector = new Byte[16];
            Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);

            Byte[] original = null; // 解密后的明文

            Rijndael Aes = Rijndael.Create();
            try
            {
                // 开辟一块内存流，存储密文
                using (MemoryStream Memory = new MemoryStream(encryptedBytes))
                {
                    // 把内存流对象包装成加密流对象
                    using (CryptoStream Decryptor = new CryptoStream(Memory,
                    Aes.CreateDecryptor(bKey, bVector),
                    CryptoStreamMode.Read))
                    {
                        // 明文存储区
                        using (MemoryStream originalMemory = new MemoryStream())
                        {
                            Byte[] Buffer = new Byte[1024];
                            Int32 readBytes = 0;
                            while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
                            {
                                originalMemory.Write(Buffer, 0, readBytes);
                            }

                            original = originalMemory.ToArray();
                        }
                    }
                }
            }
            catch
            {
                original = null;
            }
            return Encoding.UTF8.GetString(original);
        }



        /// <summary>
        /// AES加密(无向量)
        /// </summary>
        /// <param name="plainBytes">被加密的明文</param>
        /// <param name="key">密钥</param>
        /// <returns>密文</returns>
        public static string AESEncrypt(String Data, String Key)
        {
            MemoryStream mStream = new MemoryStream();
            RijndaelManaged aes = new RijndaelManaged();

            byte[] plainBytes = Encoding.UTF8.GetBytes(Data);
            Byte[] bKey = new Byte[32];
            Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);

            aes.Mode = CipherMode.ECB;
            aes.Padding = PaddingMode.PKCS7;
            aes.KeySize = 128;
            //aes.Key = _key;
            aes.Key = bKey;
            //aes.IV = _iV;
            CryptoStream cryptoStream = new CryptoStream(mStream, aes.CreateEncryptor(), CryptoStreamMode.Write);
            try
            {
                cryptoStream.Write(plainBytes, 0, plainBytes.Length);
                cryptoStream.FlushFinalBlock();
                return Convert.ToBase64String(mStream.ToArray());
            }
            finally
            {
                cryptoStream.Close();
                mStream.Close();
                aes.Clear();
            }
        }


        /// <summary>
        /// AES解密(无向量)
        /// </summary>
        /// <param name="encryptedBytes">被加密的明文</param>
        /// <param name="key">密钥</param>
        /// <returns>明文</returns>
        public static string AESDecrypt(String Data, String Key)

        {
            Byte[] encryptedBytes = Convert.FromBase64String(Data);
            Byte[] bKey = new Byte[32];
            Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);

            MemoryStream mStream = new MemoryStream(encryptedBytes);
            //mStream.Write( encryptedBytes, 0, encryptedBytes.Length );
            //mStream.Seek( 0, SeekOrigin.Begin );
            RijndaelManaged aes = new RijndaelManaged();
            aes.Mode = CipherMode.ECB;
            aes.Padding = PaddingMode.PKCS7;
            aes.KeySize = 128;
            aes.Key = bKey;
            //aes.IV = _iV;
            CryptoStream cryptoStream = new CryptoStream(mStream, aes.CreateDecryptor(), CryptoStreamMode.Read);
            try
            {
                byte[] tmp = new byte[encryptedBytes.Length + 32];
                int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length + 32);
                byte[] ret = new byte[len];
                Array.Copy(tmp, 0, ret, 0, len);
                return Encoding.UTF8.GetString(ret);
            }
            finally
            {
                cryptoStream.Close();
                mStream.Close();
                aes.Clear();
            }
        }




    }


    /// <summary>
    /// 图片压缩
    /// </summary>
    /// <param name="imagePath">图片文件路径</param>
    /// <param name="targetpath">保存路径</param>
    /// <param name="quality">压缩质量</param>
    public static void CompressionImage(string imagePath, string targetpath, long quality = 100)
    {
        if (!File.Exists(imagePath))
        {
            throw new FileNotFoundException();
        }
        var fileInfo = new FileInfo(imagePath);
        var fileName = fileInfo.Name.Replace(fileInfo.Extension, "");
        var fileFullName = targetpath;

        var imageByte = CompressionImage(imagePath, quality);
        var ms = new MemoryStream(imageByte);
        var image = Image.FromStream(ms);
        image.Save(fileFullName);
        ms.Close();
        ms.Dispose();
        image.Dispose();
    }
    private static byte[] CompressionImage(string imagePath, long quality)
    {
        using (var fileStream = new FileStream(imagePath, FileMode.Open))
        {
            using (var img = Image.FromStream(fileStream))
            {
                using (var bitmap = new Bitmap(img))
                {
                    var codecInfo = GetEncoder(img.RawFormat);
                    var myEncoder = System.Drawing.Imaging.Encoder.Quality;
                    var myEncoderParameters = new EncoderParameters(1);
                    var myEncoderParameter = new EncoderParameter(myEncoder, quality);
                    myEncoderParameters.Param[0] = myEncoderParameter;
                    using (var ms = new MemoryStream())
                    {
                        bitmap.Save(ms, codecInfo, myEncoderParameters);
                        myEncoderParameters.Dispose();
                        myEncoderParameter.Dispose();
                        return ms.ToArray();
                    }
                }
            }
        }
    }

    private static ImageCodecInfo GetEncoder(ImageFormat format)
    {
        var codecs = ImageCodecInfo.GetImageDecoders();
        return codecs.FirstOrDefault(codec => codec.FormatID == format.Guid);
    }
}