微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦!

C#压缩图片算法

下面是编程之家 jb51.cc 通过网络收集整理的代码片段。

编程之家小编现在分享给大家,也给大家做个参考。

    using System.IO;  
    using System.Drawing;  
    using System.Drawing.Imaging;  
    using System;  
    namespace Bll  
    {  
        /// <summary>  
        /// 图片处理类  
        /// 1、生成缩略图片或按照比例改变图片的大小和画质  
        /// 2、将生成缩略图放到指定的目录下  
        /// </summary>  
        public class ImageHepler  
        {  
            public Image ResourceImage,ReducedImage;  
            private int ImageWidth;  
            private int ImageHeight;  
            public string ErrMessage;  
      
            /// <summary>  
            /// 类的构造函数  
            /// </summary>  
            /// <param name="ImageFileName">图片文件的全路径名称</param>  
            public ImageHepler(string ImageFileName)  
            {  
                ResourceImage = Image.FromFile(ImageFileName);  
                ErrMessage = "";  
            }  
      
            public bool ThumbnailCallback()  
            {  
                return false;  
            }  
      
            /// <summary>  
            /// 生成缩略图,返回缩略图的Image对象  
            /// </summary>  
            /// <param name="Width">缩略图的宽度</param>  
            /// <param name="Height">缩略图的高度</param>  
            /// <returns>缩略图的Image对象</returns>  
            public Image GetReducedImage(int Width,int Height)  
            {  
                double LengthLong;          //存储(长和宽中)较短的长度  
                int widthOK,heightOK;      //存储实际要生成图片的长宽  
                if (Width < Height)         //判断输入的长和宽那个较短  
                {  
                    LengthLong = Width;     //把较短的存储在 LengthLonh 用于计算  
                }  
                else  
                {  
                    LengthLong = Height;  
                }  
                try  
                {  
                    //判断原图片 长和宽   
                    //原图比较长的一个边要和缩略图的边相等  
                    if (ResourceImage.Width > ResourceImage.Height)  
                    {  
                        widthOK = (int)LengthLong;  
                        heightOK = (int)(LengthLong / ResourceImage.Width * ResourceImage.Height);  
                    }  
                    else  
                    {  
                        heightOK = (int)LengthLong;  
                        widthOK = (int)LengthLong / ResourceImage.Height * ResourceImage.Width;  
      
                    }  
                    Image ReducedImage;  
                    Image.GetThumbnailImageAbort callb = new Image.GetThumbnailImageAbort(ThumbnailCallback);  
                    ReducedImage = ResourceImage.GetThumbnailImage(widthOK,heightOK,callb,IntPtr.Zero);  
                    return ReducedImage;  
                }  
                catch (Exception e)  
                {  
                    ErrMessage = e.Message;  
                    return null;  
                }  
            }  
      
            /// <summary>  
            /// 生成缩略图,将缩略图文件保存到指定的路径  
            /// </summary>  
            /// <param name="Width">缩略图的宽度</param>  
            /// <param name="Height">缩略图的高度</param>  
            /// <param name="targetFilePath">缩略图保存的全文件名,(带路径),参数格式:D:\Images\filename.jpg</param>  
            /// <returns>成功返回true,否则返回false</returns>  
            public bool GetReducedImage(int Width,int Height,string targetFilePath)  
            {  
                double LengthLong;          //存储(长和宽中)较短的长度  
                int widthOK,heightOK;      //存储实际要生成图片的长宽  
                if (Width < Height)         //判断输入的长和宽那个较短  
                {  
                    LengthLong = Width;     //把较短的存储在 LengthLonh 用于计算  
                }  
                else  
                {  
                    LengthLong = Height;  
                }  
                try  
                {  
                    //判断原图片 长和宽   
                    //原图比较长的一个边要和缩略图的边相等  
                    if (ResourceImage.Width > ResourceImage.Height)  
                    {  
                        widthOK = (int)LengthLong;  
                        heightOK = (int)(LengthLong / ResourceImage.Width * ResourceImage.Height);  
                    }  
                    else  
                    {  
                        heightOK = (int)LengthLong;  
                        widthOK = (int)LengthLong / ResourceImage.Height * ResourceImage.Width;  
                    }  
                    Image.GetThumbnailImageAbort callb = new Image.GetThumbnailImageAbort(ThumbnailCallback);  
                    ReducedImage = ResourceImage.GetThumbnailImage(widthOK,IntPtr.Zero);  
                    ReducedImage.Save(@targetFilePath,ImageFormat.Jpeg);  
                    //ReducedImage.dispose();  
                    return true;  
                }  
                catch (Exception e)  
                {  
                    ErrMessage = e.Message;  
                    return false;  
                }  
            }  
      
            /// <summary>  
            /// 生成缩略图,返回缩略图的Image对象  
            /// </summary>  
            /// <param name="Percent">缩略图的宽度百分比 如:需要百分之80,就填0.8</param>    
            /// <returns>缩略图的Image对象</returns>  
            public Image GetReducedImage(double Percent)  
            {  
                try  
                {  
                    Image ReducedImage;  
                    Image.GetThumbnailImageAbort callb = new Image.GetThumbnailImageAbort(ThumbnailCallback);  
                    ImageWidth = Convert.ToInt32(ResourceImage.Width * Percent);  
                    ImageHeight = Convert.ToInt32(ResourceImage.Width * Percent);  
                    ReducedImage = ResourceImage.GetThumbnailImage(ImageWidth,ImageHeight,IntPtr.Zero);  
                    return ReducedImage;  
                }  
                catch (Exception e)  
                {  
                    ErrMessage = e.Message;  
                    return null;  
                }  
            }  
      
            /// <summary>  
            /// 生成缩略图,返回缩略图的Image对象  
            /// </summary>  
            /// <param name="Percent">缩略图的宽度百分比 如:需要百分之80,就填0.8</param>    
            /// <param name="targetFilePath">缩略图保存的全文件名,(带路径),参数格式:D:\Images\filename.jpg</param>  
            /// <returns>成功返回true,否则返回false</returns>  
            public bool GetReducedImage(double Percent,string targetFilePath)  
            {  
                try  
                {  
                    Image.GetThumbnailImageAbort callb = new Image.GetThumbnailImageAbort(ThumbnailCallback);  
                    ImageWidth = Convert.ToInt32(ResourceImage.Width * Percent);  
                    ImageHeight = Convert.ToInt32(ResourceImage.Width * Percent);  
                    ReducedImage = ResourceImage.GetThumbnailImage(ImageWidth,ImageFormat.Jpeg);  
                    //ReducedImage.dispose();  
                    return true;  
                }  
                catch (Exception e)  
                {  
                    ErrMessage = e.Message;  
                    return false;  
                }  
            }  
        }  
    }  


[csharp] view plaincopy

    using System;  
    using System.Data;  
    using System.Configuration;  
    using System.Linq;  
    using System.Web;  
    using System.IO;  
    using System.Collections;  
    using System.Collections.Generic;  
    using System.Security.AccessControl;  
    using System.Security.Permissions;  
    namespace Bll  
    {  
        public class FolderHelper  
        {  
            //判断文件夹是否存在  
            public static bool checkFolderExits(string path)  
            {  
                DirectoryInfo dir = new DirectoryInfo(path);  
                if (dir.Exists)//文件夹存在  
                {     
                    return true;  
                }  
                else  
                {  
                   //dir.Create();//不存在就创建一个  
                    return false;  
                }  
            }  
            //创建一个文件夹,存在就创建失败  
            public static bool CreateNewFolder(string path)  
            {  
                DirectoryInfo dir = new DirectoryInfo(path);  
      
                if (!dir.Exists)  
                {  
                    dir.Create();  
                    return true;  
                }  
                else  
                    return false;  
            }  
            /// <summary>  
            /// 在指定目录下创建指定名称文件夹  
            /// </summary>  
            /// <param name="ParentsPath"></param>  
            /// <param name="NewFolderName"></param>  
            /// <returns></returns>  
            public static bool CreateNewFolder(string ParentsPath,string NewFolderName)  
            {  
                string CreatePath = ParentsPath + @"\" + NewFolderName;  
                DirectoryInfo dir = new DirectoryInfo(CreatePath);  
      
                if (!dir.Exists)  
                {  
                    dir.Create();  
                    return true;  
                }  
                else  
                    return false;  
            }  
            /// <summary>  
            /// 返回目录下的所有文件名  
            /// </summary>  
            /// <param name="path"></param>  
            /// <returns></returns>  
            public static ArrayList getAllFiles(string path)  
            {  
                DirectoryInfo dir = new DirectoryInfo(path);  
                if (dir.Exists)  
                {  
                    FileInfo[] fileinfo = dir.GetFiles();  
                    ArrayList list = new ArrayList();  
                    foreach (FileInfo f in fileinfo)  
                    {  
                        list.Add(f.Name);  
                    }  
                    return list;  
                }  
                else  
                    return null;  
            }  
            /// <summary>  
            /// 计算文件夹的大小  
            /// </summary>  
            /// <param name="d"></param>  
            /// <returns></returns>  
            public static long Dirsize(DirectoryInfo d)  
            {  
                long Size = 0;  
                // Add file sizes.  
                FileInfo[] fis = d.GetFiles();//获得目录文件列表  
                foreach (FileInfo fi in fis)  
                {  
                    Size += fi.Length;  
                }  
                // Add subdirectory sizes.  
                DirectoryInfo[] dis = d.GetDirectories();//获取目录子目录列表  
                foreach (DirectoryInfo di in dis)  
                {  
                    Size += Dirsize(di);  
                }  
                return Size;  
            }  
            /// <summary>  
            /// 把文件夹得大小转换成比较合适的表示单位  
            /// </summary>  
            /// <param name="size"></param>  
            /// <returns></returns>  
            public static string ViewSize(long size)  
            {  
                long m=size;  
                string viewstr;  
                  
                if ((m / 1024) > 0)//表示可以转换成KB  
                {  
                    m = m / 1024;//转换成KB  
                      
                    if ((m / 1024) > 0)//表示可以转换成MB  
                    {  
                        m = m / 1024;//转换成MB了  
      
                        if ((m / 1024) > 0)//表示可以转换成GB  
                        {  
                            m = m / 1024;//转换成GB了  
                            viewstr = m.ToString() + "GB";  
                        }  
                        else  
                        {  
                            viewstr = m.ToString() + "MB";  
                        }  
                    }  
                    else  
                    {  
                        viewstr = m.ToString() + "KB";  
                    }  
                }  
                else  
                {  
                    viewstr = m.ToString() + "byte";  
                }  
                return viewstr;  
            }  
            /// <summary>  
            /// 删除指定目录和内容  
            /// </summary>  
            /// <param name="dir"></param>  
            /// <returns></returns>  
            public static bool delDir(string dir)  
            {  
                bool flag = false;  
                DirectoryInfo d = new DirectoryInfo(dir);  
                if (d.Exists)//判断目录是否存在  
                {  
                    try  
                    {  
                        d.Delete();  
                        flag = true;  
                    }  
                    catch (Exception e) { flag = false; }  
                }  
                return flag;  
            }  
            /// <summary>  
            /// 删除指定文件  
            /// </summary>  
            /// <param name="fil"></param>  
            /// <returns></returns>  
            public static bool delFile(string fil)  
            {  
                bool flag = false;  
                FileInfo d = new FileInfo(fil);  
                if (d.Exists)//判断目录是否存在  
                {  
                    try  
                    {  
                        d.Delete();  
                        flag = true;  
                    }  
                    catch (Exception e) { flag = false; }  
                }  
                return flag;  
            }  
            public static void copy(string sourceDirectory,string targetDirectory)  
            {  
                DirectoryInfo disource = new DirectoryInfo(sourceDirectory);  
                DirectoryInfo diTarget = new DirectoryInfo(targetDirectory);  
      
                copyAll(disource,diTarget);  
            }  
            /// <summary>  
            /// 复制目录及子文件到指定目录  
            /// </summary>  
            /// <param name="source"></param>  
            /// <param name="target"></param>  
            public static void copyAll(DirectoryInfo source,DirectoryInfo target)  
            {  
                // Check if the target directory exists,if not,create it.  
                if (Directory.Exists(target.FullName) == false)  
                {  
                    Directory.CreateDirectory(target.FullName);  
                }  
      
                // copy each file into it's new directory.  
                foreach (FileInfo fi in source.GetFiles())  
                {  
                    Console.WriteLine(@"copying {0}\{1}",target.FullName,fi.Name);  
                    fi.copyTo(Path.Combine(target.ToString(),fi.Name),true);  
                }  
      
                // copy each subdirectory using recursion.  
                foreach (DirectoryInfo disourceSubDir in source.GetDirectories())  
                {  
                    DirectoryInfo nextTargetSubDir =  
                        target.Createsubdirectory(disourceSubDir.Name);  
                    copyAll(disourceSubDir,nextTargetSubDir);  
                }  
            }  
      
      
      
            /// <summary>  
            /// 循环读取某个目录下的所有文件和目录,查询有关每一项的一些信息。返回一个文件列表  
            /// </summary>  
            /// <param name="strCurrentDir"></param>  
            public static List<fileEntity> FileView(string strCurrentDir)  
            {  
                List<fileEntity> fileList = new List<fileEntity>();  
                DirectoryInfo dir = new DirectoryInfo(strCurrentDir);  
      
                foreach (FileSystemInfo fsi in dir.GetFileSystemInfos())//这个循环再读取文件的信息  
                {  
                    try  
                    {  
                        //FileSystemInfo 对象可以表示文件或目录,从而可以作为 FileInfo 或 DirectoryInfo 对象的基础。 当分析许多文件和目录时,请使用该基类。  
                        FileInfo fi;  
                        DirectoryInfo di;  
                        //创建一个自己写的实体类的实体  
                        fileEntity newfile = new fileEntity();  
                        if (fsi is FileInfo)//外层循环读取文件信息  
                        {  
                            //表示当前fsi是文件  
                            fi = (FileInfo)fsi;  
                            newfile.fileName = fi.Name;  
                            newfile.fileExt = fi.Extension;  
                            newfile.fileSize = fi.Length;  
                            newfile.FileModify = fi.LastWriteTime;  
                            //通过扩展名来选择文件显示图标  
                            switch (newfile.fileExt)  
                            {  
                                case ".gif":  
                                    newfile.picName = "gif.gif";  
                                    break;  
                                default:  
                                    newfile.picName = "other.gif";  
                                    break;  
                            }  
                            newfile.picName = "<img src='" + newfile.picName + "' width=25 height=20>";  
                        }  
                        else  
                        {  
                            di = (DirectoryInfo)fsi;  
                            newfile.fileName = di.Name;  
                            newfile.fileSize = Dirsize(di);//调用计算文件夹大小的方法  
                            newfile.FileModify = di.LastWriteTime;  
                            newfile.picName = "<img src='directory.gif' width=25 height=20>";  
                        }  
                        fileList.Add(newfile);  
                    }  
                    catch (Exception e) { }  
                }  
                return fileList;  
      
            }  
      
      
            /// <summary>  
            /// 显示目录文件  
            /// </summary>  
            /// <param name="path"></param>  
            public static void All(string path)  
            {  
                FileInfo fi;//文件  
                DirectoryInfo di;//目录  
                DirectoryInfo dir=null;  
                int i = 0; //控制行的颜色  
                try  
                {  
                    dir = new DirectoryInfo(path);  
                }  
                catch (Exception e) { }  
                foreach (FileSystemInfo fsi in dir.GetFileSystemInfos())  
                {  
                    try  
                    {  
                        fileEntity newfile = new fileEntity();  
                        FolderEntity folder = new FolderEntity();  
                        newfile.fileName = "";  
                        newfile.picName = "";  
                        newfile.fileExt = "";  
                        newfile.fileSize = 0;  
                        folder.folderName = "";  
                        folder.picName = "";  
      
                        i += 1;  
                        if (fsi is FileInfo)//判断当前读取的是不是一个文件  
                        {  
                            //表示当前fsi是文件  
                            fi = (FileInfo)fsi;  
                            newfile.fileName = fi.Name;  
                            newfile.fileExt = fi.Extension;  
                            newfile.fileSize = fi.Length;  
                            newfile.FileModify = fi.LastWriteTime;  
      
                            //将文件加上可以下载文件链接  
      
      
                            newfile.fileName = "<a href='........'></a>";  
      
      
                            //通过扩展名来选择文件显示图标  
      
                            //Response.Write(Session["DataBasePath"].ToString()+"\\filetype\\"+pfun.getFileExt(FileExt)+".gif");  
      
                            if (fsi.Exists)  
                            {  
                                switch (newfile.fileExt)  
                                {  
                                    case ".gif":  
                                        newfile.picName = "gif.gif";  
                                        break;  
                                    default:  
                                        newfile.picName = "other.gif";  
                                        break;  
                                }  
                            }  
                            else  
                            {  
                                newfile.picName = "unkNown.gif";  
                            }  
      
      
                            /* 
                            switch(FileExt) 
                            { 
                                case ".gif": 
                                    FilePic = "gif.gif"; 
                                    break; 
                                default: 
                                    FilePic = "other.gif"; 
                                    break; 
                            } 
                            */  
      
                            newfile.picName = "<img src='filetype/" + newfile.picName + "' width=16 height=16>";  
      
                        }  
                        else  
                        {  
                            //当前为目录  
                            di = (DirectoryInfo)fsi;  
                            folder.folderName = di.Name;  
      
                            //给目录加上链接  
      
                            folder.folderName = "<a href='.......'><a>";  
                            folder.lastTime = di.LastWriteTime;  
                            folder.picName = "<img src='filetype/folder.gif' width=16 height=16>";  
      
                        }  
                    }catch(Exception e){}  
                }  
      
      
            }  
        }  
    }  

以上是编程之家(jb51.cc)为你收集整理的全部代码内容,希望文章能够帮你解决所遇到的程序开发问题。

如果觉得编程之家网站内容还不错,欢迎将编程之家网站推荐给程序员好友。

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐