C# 图片，字节流，路径文件的转换

 /// <summary>
    /// 图片，字节流，路径文件的转换
    /// </summary>
    class BitmapImageHelper
    {
        //待测试
        public Image GetImageHttp(string url, int width)
        {
            Image image = null;
            int BytesToRead = 100;
            if (!string.IsNullOrEmpty(url))
            {
                WebRequest request = WebRequest.Create(new Uri(url, UriKind.Absolute));
                request.Timeout = -1;
                WebResponse response = request.GetResponse();
                if (response != null)
                {
                    Stream responseStream = response.GetResponseStream();

                    BinaryReader reader = new BinaryReader(responseStream);
                    MemoryStream memoryStream = new MemoryStream();

                    byte[] bytebuffer = new byte[BytesToRead];
                    int bytesRead = reader.Read(bytebuffer, 0, BytesToRead);

                    while (bytesRead > 0)
                    {
                        memoryStream.Write(bytebuffer, 0, bytesRead);
                        bytesRead = reader.Read(bytebuffer, 0, BytesToRead);
                    }

                    memoryStream.Close();
                    reader.Close();
                    responseStream.Close();
                    response.Close();
                }
            }
            return image;
        }

        /// <summary>
        /// 获取远程地址的图片(经测试显示参数无效,可以保存到指定文件夹下)，需进一步测试
        /// </summary>
        /// <param name="url">远程地址</param>
        /// <returns></returns>
        public static Image GetImageHttp(string url)
        {
            try
            {
                LogerHelper.CreateLogTxt($"GetImageHttp 照片地址{url}");
                WebRequest webreq = WebRequest.Create(new Uri(url, UriKind.Absolute));
                WebResponse webres = webreq.GetResponse();
                // 以字符流的方式读取HTTP响应，使用Using// 释放资源
                using (Stream stream = webres.GetResponseStream())
                {
                    //string path = Directory.GetCurrentDirectory() + "\\Photos";
                    string path = @"D:\Photos";//photos为保存到的照片名称
                    Image.FromStream(stream).Save(path);
                    return Image.FromStream(stream);
                }
            }
            catch (Exception ex)
            {
                LogerHelper.CreateLogTxt($"获取照片错误{ex.Message}");
            }
            return null;
        }

        /// <summary>
        /// 获取远程地址的图片
        /// </summary>
        /// <param name="url">远程地址</param>
        /// <returns></returns>
        public static Image GetImagePath(string url)
        {
           return UrlToImage(url);
        }
        /// <summary>
        /// 根据远程地址获取图片流
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static byte[] GetImageBytePath(string url)
        {
            WebClient mywebclient = new WebClient();
            byte[] Bytes = mywebclient.DownloadData(url);
            return Bytes;
        }


        #region 把在线图片转为base64
        /// <summary>
        /// 
        /// </summary>
        /// <param name="fileFullName">远程成在线图片地址</param>
        /// <returns></returns>
        public static string ImageToBase64(string fileFullName)
        {
            try
            {
                LogerHelper.CreateLogTxt($"ImageToBase64 照片地址{fileFullName}");
                Image img = UrlToImage(fileFullName);
                Bitmap bmp = new Bitmap(img);
                MemoryStream ms = new MemoryStream();
                var suffix = fileFullName.Substring(fileFullName.LastIndexOf('.') + 1,
                    fileFullName.Length - fileFullName.LastIndexOf('.') - 1).ToLower();
                var suffixName = suffix == "png" || suffix == "jpng"
                    ? ImageFormat.Png
                    : suffix == "jpg" || suffix == "jpeg" 
                        ? ImageFormat.Jpeg
                        : suffix == "bmp"
                            ? ImageFormat.Bmp
                            : suffix == "gif"
                                ? ImageFormat.Gif
                                : ImageFormat.Jpeg;

                bmp.Save(ms, suffixName);
                byte[] arr = new byte[ms.Length]; ms.Position = 0;
                ms.Read(arr, 0, (int)ms.Length); ms.Close();
                string base64Str = Convert.ToBase64String(arr);
                return PrefectBase64(base64Str);
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// <summary>
        /// 通过远程地址获取图片， 会出现（GDI+中发生一般性错误的解决方法：释放图片资源）错误，未解决
        /// </summary>
        /// <param name="url">远程地址串</param>
        /// <returns></returns>
        private static Image UrlToImage(string url)
        {
            WebClient mywebclient = new WebClient();
            byte[] Bytes = mywebclient.DownloadData(url);
            MemoryStream ms = new MemoryStream(Bytes);
            Image outputImg = Image.FromStream(ms);
            return outputImg;
            //using (MemoryStream ms = new MemoryStream(Bytes))
            //{
            //    Image outputImg = Image.FromStream(ms);
            //    //GetBytes(outputImg);
            //    return outputImg;
               
            //}
        }

        private static string PrefectBase64(string Base64Str)
        {
            string dummyData = Base64Str.Replace("%", "").Replace(",", "").Replace(" ", "+");
            if (dummyData.Length % 4 > 0)
            {
                dummyData = dummyData.PadRight(dummyData.Length + 4 - dummyData.Length % 4, '=');
            }
            return dummyData;
        }


        #region Image To base64      
        /// <summary>
        /// Image 转成 base64
        /// </summary>
        /// <param name="fileFullName"></param>
        public static string ImageToBase64E(Image img)
        {
            try
            {
                Bitmap bmp = new Bitmap(img);
                MemoryStream ms = new MemoryStream();
                bmp.Save(ms, ImageFormat.Jpeg);
                byte[] arr = new byte[ms.Length];
                ms.Position = 0;
                ms.Read(arr, 0, (int)ms.Length);
                ms.Close();
                return Convert.ToBase64String(arr);
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        public static string ImageToBase64E(string url)
        {
            return ImageToBase64E(UrlToImage(url));
        }
        #endregion

        #endregion


        /// <summary>
        /// base64转图片
        /// </summary>
        /// <param name="base64"></param>
        public static Image Base64ToImage(string base64)
        {
            try
            {
                base64 = base64.Replace("data:image/png;base64,", "").Replace("data:image/jgp;base64,", "").Replace("data:image/jpg;base64,", "").Replace("data:image/jpeg;base64,", "").Replace("data:image/jpng;base64,", "").Replace("data:image/jpng;base64;", "");//将base64头部信息替换
                byte[] bytes = Convert.FromBase64String(base64);
                MemoryStream memStream = new MemoryStream(bytes);
                Image mImage = Image.FromStream(memStream);
                return mImage;

                //Bitmap bp = new Bitmap(mImage);
                //string path = @"D:\uploads";
                //if (!Directory.Exists(path))
                //{
                //    Directory.CreateDirectory(path);
                //}
                //DateTime now = DateTime.Now;
                //string fileName = "images";
                //string filePath = path + "\\" + fileName;
                //bp.Save(filePath, System.Drawing.Imaging.ImageFormat.Jpeg);//注意保存路径
            }
            catch (Exception ex)
            {
                LogerHelper.CreateLogTxt($"base64转图片失败，错误详情:  {ex.Message}");
                throw;
            }
        }

        /// <summary>
        /// 图片转字节数组
        /// </summary>
        /// <param name="Picture"></param>
        /// <returns></returns>
        public static byte[] ImageToByte(Image Pic)
        {
            MemoryStream ms = new MemoryStream();
            if (Pic == null)
                return new byte[ms.Length];
            Pic.Save(ms, ImageFormat.Jpeg);
            byte[] BPicture = new byte[ms.Length];
            BPicture = ms.GetBuffer();
            return BPicture;
        }

        /// <summary>
        /// 字节流转图片
        /// </summary>
        /// <param name="btImage"></param>
        /// <returns></returns>
        public static Image ByteToImage(byte[] byImage)
        {
            if (byImage.Length == 0)
                return null;
            MemoryStream ms = new MemoryStream(byImage);
            Image image = Image.FromStream(ms);
            return image;
        }

        /// <summary> 
        /// 根据图片路径返回图片的字节流byte[] 
        /// </summary> 
        /// <param name="imagePath">图片路径</param> 
        /// <returns>返回的字节流</returns> 
        public static byte[] getImageByte(string imagePath)
        {
            FileStream files = new FileStream(imagePath, FileMode.Open);
            byte[] imgByte = new byte[files.Length];
            files.Read(imgByte, 0, imgByte.Length);
            files.Close();
            return imgByte;
        }

        /// <summary>
        /// GDI+中发生一般性错误的解决方法：释放图片资源
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        private static byte[] GetBytes(Image image)
        {
            try
            {
                if (image == null) return null;
                using (Bitmap bitMap = new Bitmap(image))
                {
                    using (MemoryStream stream = new MemoryStream())
                    {
                        bitMap.Save(stream,ImageFormat.Jpeg);
                        return stream.GetBuffer();
                    }
                }
            }           
            finally
            {
                if (image != null)
                {
                    image.Dispose();
                    image = null;
                }
            }
        }
    }
    
    LogerHelper类见链接：https://mp.csdn.net/mp_blog/creation/editor/89875205
    ​

​​​​​​​转LogerHelper链接https://blog.csdn.net/cn_514/article/details/89875205​​​​​​​