C# WinForm 文件上传下载

其他 2019-06-28 17:18:02 阅读次数: 0
         /// <summary>
        /// WebClient上传文件至服务器
        /// </summary>
        /// <param name="localFilePath">文件名，全路径格式</param>
        /// <param name="serverFolder">服务器文件夹路径</param>
        /// <param name="reName">是否需要修改文件名，这里默认是日期格式</param>
        /// <returns></returns>
         public   static   bool  UploadFile( string  localFilePath,  string  serverFolder, bool  reName)
         {
            string fileNameExt, newFileName, uriString;
            if (reName)
            {
                fileNameExt = localFilePath.Substring(localFilePath.LastIndexOf(".") + 1);
                newFileName = DateTime.Now.ToString("yyMMddhhmmss") + fileNameExt;
            }
            else
            {
                newFileName = localFilePath.Substring(localFilePath.LastIndexOf("\\")+1);
            }

            if (!serverFolder.EndsWith("/") && !serverFolder.EndsWith("\\"))
            {
                serverFolder = serverFolder + "/";
            }

            uriString = serverFolder + newFileName;   //服务器保存路径
            /// 创建WebClient实例
            WebClient myWebClient = new WebClient();
            myWebClient.Credentials = CredentialCache.DefaultCredentials;

            // 要上传的文件
            FileStream fs = new FileStream(newFileName, FileMode.Open, FileAccess.Read);
            BinaryReader r = new BinaryReader(fs);
            try
            {
                //使用UploadFile方法可以用下面的格式
                //myWebClient.UploadFile(uriString,"PUT",localFilePath);
                byte[] postArray = r.ReadBytes((int)fs.Length);
                Stream postStream = myWebClient.OpenWrite(uriString, "PUT");
                if (postStream.CanWrite)
                {
                    postStream.Write(postArray, 0, postArray.Length);
                }
                else
                {
                    MessageBox.Show("文件目前不可写！");
                }
                postStream.Close();
            }
            catch
            {
                //MessageBox.Show("文件上传失败，请稍候重试~");
                return false;
            }

            return true;
        }


     

     

    /// <summary>
        /// 下载服务器文件至客户端
        /// </summary>
        /// <param name="uri">被下载的文件地址</param>
        /// <param name="savePath">另存放的目录</param>
         public   static   bool  Download( string  uri,  string  savePath)
         {
            string fileName;  //被下载的文件名
            if (uri.IndexOf("\\") > -1)
            {
                fileName = uri.Substring(uri.LastIndexOf("\\") + 1);
            }
            else
            {
                fileName = uri.Substring(uri.LastIndexOf("/") + 1);  
            }


            if (!savePath.EndsWith("/") && !savePath.EndsWith("\\"))
            {
                savePath = savePath + "/";
            }

            savePath += fileName;   //另存为的绝对路径＋文件名

            WebClient client = new WebClient();
            try
            {
                client.DownloadFile(uri, savePath);
            }
            catch
            {
                return false;
            }

            return true;
        }  


************************************************
命名空间
System.Net;
System.IO;
上传IIS虚拟目录需要给写入权限，下载可能需要匿名访问权限。

文件流的方式：

using  System;
 using  System.Collections.Generic;
 using  System.Linq;
 using  System.Text;
 using  System.IO;

 namespace  ProgressStudy
{
     public   interface  IDownloadServices
    {
         ///   <summary>
         ///  每次下载的大小
         ///   </summary>
         int  DownloadSize {  get ;  set ; }

         ///   <summary>
         ///  待下载的文件名，完全路径格式
         ///   </summary>
         string  FullFileName {  get ;  set ; }

         ///   <summary>
         ///  文件总大小
         ///   </summary>
         long  FileSize {  get ; }

         ///   <summary>
         ///  获取文件的数据流对象
         ///   </summary>
         ///   <returns></returns>
         byte [] GetBuffer();
    }

     ///   <summary>
     ///  下载服务器方法类
     ///   </summary>
     public   class  DownloadServices : IDownloadServices, IDisposable
    {
         ///   <summary>
         ///  每次下载大小
         ///   </summary>
         private   const   int  PROGRESS_UNIT_SIZE  =   1024 ;
         private  FileStream FSServer  =   null ;
         private  BinaryReader BRServer  =   null ;

         ///   <summary>
         ///  构造函数中初始化对象
         ///   </summary>
         public  DownloadServices( string  fullFileName)
        {
             this ._FullFileName  =  fullFileName;
             //  初始化创建对象
            CreateFileStream();
        }

         ///   <summary>
         ///   创建对象
         ///   </summary>
         ///   <returns></returns>
         private   bool  CreateFileStream()
        {
             try
            {
                FSServer  =   new  FileStream(FullFileName, FileMode.Open, FileAccess.Read);
                BRServer  =   new  BinaryReader(FSServer);

                _FileSize  =  FSServer.Length;
                 return   true ;
            }
             catch  {  return   false ; }
        }

         ///   <summary>
         ///  销毁对象
         ///   </summary>
         private   void  CloseFileStream()
        {
             if  (FSServer  !=   null )
            {
                FSServer.Close();
            }
             if  (BRServer  !=   null )
            {
                BRServer.Close();
            }
        }
         #region  IDownloadServices 成员
         private   string  _FullFileName  =   string .Empty;
         ///   <summary>
         ///  文件名
         ///   </summary>
         public   string  FullFileName
        {
             get
            {
                 return   this ._FullFileName;
            }
             set
            {
                 this ._FullFileName  =  value;
            }
        }

         private   long  _FileSize;
         ///   <summary>
         ///  文件总大小
         ///   </summary>
         public   long  FileSize
        {
             get
            {
                 return  _FileSize;
            }
        }

         private   int  _DownloadSize  =   1024 ;
         ///   <summary>
         ///  每次下载的大小
         ///   </summary>
         public   int  DownloadSize
        {
             get
            {
                 return   this ._DownloadSize;
            }
             set
            {
                 this ._DownloadSize  =  value;
            }
        }

         ///   <summary>
         ///  获取文件流数据
         ///   </summary>
         ///   <returns></returns>
         public   byte [] GetBuffer()
        {
            Byte[] buffer  =  BRServer.ReadBytes(PROGRESS_UNIT_SIZE);
             return  buffer;
        }
         #endregion

         #region  IDisposable 成员
         ///   <summary>
         ///  销毁对象
         ///   </summary>
         public   void  Dispose()
        {
            CloseFileStream();
        }
         #endregion
    }
}
using  System;
 using  System.Collections.Generic;
 using  System.Linq;
 using  System.Text;
 using  System.IO;

 namespace  ProgressStudy
{

     public   class  DownloadCommon : IDisposable
    {

         public   delegate   void  DownloadHandler( object  sender);
         ///   <summary>
         ///  上传前方法，参数为文件总大小
         ///   </summary>
         public   static   event  DownloadHandler BeforeDownload;
         ///   <summary>
         ///  上传过程中方法，参数为当次上传文件大小
         ///   </summary>
         public   static   event  DownloadHandler DoDownload;
         ///   <summary>
         ///  上传完成方法，参数为当次上传文件大小
         ///   </summary>
         public   static   event  DownloadHandler AfterDownload;
         ///   <summary>
         ///  上传出错方法，参数为错误信息
         ///   </summary>
         public   static   event  DownloadHandler ErrorDownload;

         private  FileStream fs  =   null ;
         private  BinaryWriter bw  =   null ;

         private   int  _DownSize  =   1024 ;
         ///   <summary>
         ///  每次下载的数据大小(单位：字节)，默认 1024 字节
         ///   </summary>
         public   int  DownSize
        {
             get  {  return   this ._DownSize; }
             set  {  this ._DownSize  =  value; }
        }

         ///   <summary>
         ///  下载文件
         ///   </summary>
         ///   <param name="localFile"> 本地文件保存路径(完全路径格式) </param>
         ///   <param name="fullFileName"> 服务器文件路径(完全路径格式) </param>
         public   void  Download( string  localFile,  string  fullFileName)
        {
            DownloadServices down  =   new  DownloadServices(fullFileName) { DownloadSize  =  DownSize };

             //  待下载的总文件大小
             long  fileSize  =  down.FileSize;

             try
            {
                 //  读取本地文件到流对象中
                fs  =   new  FileStream(localFile, FileMode.OpenOrCreate, FileAccess.ReadWrite);
                bw  =   new  BinaryWriter(fs);

                 //  上传前调用方法
                 if  (BeforeDownload  !=   null )
                {
                    BeforeDownload(fileSize);
                }
                Byte[] buffer;
                 while  ((buffer  =  down.GetBuffer()).Length  >   0 )
                {
                    bw.Write(buffer);
                    bw.Flush();
                     //  下载过程中
                     if  (DoDownload  !=   null )
                    {
                        DoDownload(buffer.Length);
                    }
                }
                 //  下载完毕
                 if  (AfterDownload  !=   null )
                {
                    AfterDownload( null );
                }
            }
             catch  (Exception ex)
            {
                 if  (ErrorDownload  !=   null )
                {
                    ErrorDownload(ex.Message);
                }
            }
             finally
            {
                down.Dispose();
                Dispose();
            }
        }

         ///   <summary>
         ///  销毁对象
         ///   </summary>
         private   void  CloseFileStream()
        {
             if  (bw  !=   null )
            {
                bw.Close();
            }
             if  (fs  !=   null )
            {
                fs.Close();
            }

            BeforeDownload  =   null ;
            DoDownload  =   null ;
            AfterDownload  =   null ;
            ErrorDownload  =   null ;
        }

         #region  IDisposable 成员
         ///   <summary>
         ///  释放对象
         ///   </summary>
         public   void  Dispose()
        {
            CloseFileStream();
        }
         #endregion
    }
}
using  System;
 using  System.Collections.Generic;
 using  System.Linq;
 using  System.Text;
 using  System.IO;

 namespace  ProgressStudy
{
     public   interface  IUploadServices
    {
         ///   <summary>
         ///  文件名(不含路径格式)
         ///   </summary>
         string  FileName {  get ; }

         ///   <summary>
         ///  上载
         ///   </summary>
         ///   <param name="buffer"></param>
         ///   <param name="isEnd"></param>
         void  Upload( byte [] buffer,  bool  isEnd);
    }

     ///   <summary>
     ///  服务器端方法
     ///   </summary>
     public   class  UploadServices : IUploadServices,IDisposable
    {
         private  FileStream FSServer  =   null ;
         private   static  BinaryWriter BWServer  =   null ;

         private   string  _FileName  =   string .Empty;
         ///   <summary>
         ///  待上传的文件名，不包含路径
         ///   </summary>
         public   string  FileName
        {
             get  {  return   this ._FileName; }
             set  {  this ._FileName  =  value; }
        }

         ///   <summary>
         ///  上传文件保存路径，完全路径格式
         ///   </summary>
         private   string  ServerPath
        {
             get
            {
                 return  Path.Combine( " D:\\Test\\ProgressUpload " , FileName);
            }
        }

         public  UploadServices()
        {

        }

         public  UploadServices( string  fileName)
        {
             this ._FileName  =  fileName;
             ///  初始化对象
            CreateFileStream();
        }

         ///   <summary>
         ///   创建对象
         ///   </summary>
         ///   <returns></returns>
         private   bool  CreateFileStream()
        {
             try
            {
                FSServer  =   new  FileStream(ServerPath, FileMode.Create, FileAccess.Write);
                BWServer  =   new  BinaryWriter(FSServer);
                 return   true ;
            }
             catch  {  return   false ; }
        }

         ///   <summary>
         ///  每次读取固定字节写入文件
         ///   </summary>
         ///   <param name="buffer"></param>
         ///   <param name="isEnd"></param>
         public   void  Upload( byte [] buffer,  bool  isEnd)
        {
            BWServer.Write(buffer);
            BWServer.Flush();
        }

         ///   <summary>
         ///  关闭对象
         ///   </summary>
         private   void  CloseFileStream()
        {
             if  (BWServer  !=   null )
            {
                BWServer.Close();
                BWServer  =   null ;
            }
             if  (FSServer  !=   null )
            {
                FSServer.Close();
                FSServer  =   null ;
            }
        }

         #region  IDisposable 成员
         ///   <summary>
         ///  销毁对象
         ///   </summary>
         public   void  Dispose()
        {
            CloseFileStream();
        }
         #endregion
    }
}
using  System;
 using  System.Collections.Generic;
 using  System.Linq;
 using  System.Text;
 using  System.IO;

 namespace  ProgressStudy
{
     ///   <summary>
     ///  客户端方法
     ///   </summary>
     public   class  UploadCommon : IDisposable
    {
         public   delegate   void  UploadHander( object  sender);
         ///   <summary>
         ///  上传前方法，参数为文件总大小
         ///   </summary>
         public   static   event  UploadHander BeforeUpLoad;
         ///   <summary>
         ///  上传过程中方法，参数为当次上传文件大小
         ///   </summary>
         public   static   event  UploadHander DoUpLoad;
         ///   <summary>
         ///  上传完成方法，参数为当次上传文件大小
         ///   </summary>
         public   static   event  UploadHander AfterUpLoad;
         ///   <summary>
         ///  上传出错方法，参数为错误信息
         ///   </summary>
         public   static   event  UploadHander ErrorUpLoad;

         private  FileStream fs  =   null ;
         private  BinaryReader br  =   null ;

         private   int  _UploadSize  =   1024 ;
         ///   <summary>
         ///  每次上载的文件数据大小(单位：字节)，默认 1024 字节
         ///   </summary>
         public   int  UploadSize
        {
             get  {  return   this ._UploadSize; }
             set  {  this ._UploadSize  =  value; }
        }

         ///   <summary>
         ///  通过字节流上传，使用委托控制进度条
         ///   </summary>
         ///   <param name="localFile"> 本地路径 </param>
         public   void  UpLoadFile( string  localFile)
        {
             //  服务器端上传服务
            UploadServices upload  =   new  UploadServices(Path.GetFileName(localFile));

             try
            {
                fs  =   new  FileStream(localFile, FileMode.Open, FileAccess.Read);
                br  =   new  BinaryReader(fs);

                 //  上传前调用方法
                 if  (BeforeUpLoad  !=   null )
                {
                    BeforeUpLoad(fs.Length);
                }
                 while  ( true )
                {
                    Byte[] buffer  =  br.ReadBytes(UploadSize);
                     if  (buffer.Length  <  UploadSize)
                    {
                        upload.Upload(buffer,  true );
                         //  上传完毕使用方法
                         if  (AfterUpLoad  !=   null )
                        {
                            AfterUpLoad(UploadSize);
                        }
                         break ;
                    }
                     else
                    {
                        upload.Upload(buffer,  false );
                         if  (DoUpLoad  !=   null )
                        {
                            DoUpLoad(UploadSize);
                        }
                    }
                }
            }
             catch  (Exception ex)
            {
                 if  (ErrorUpLoad  !=   null )
                {
                    ErrorUpLoad(ex.Message);
                }
            }
             finally
            {
                Dispose();
                upload.Dispose();
            }
        }

         ///   <summary>
         ///  销毁对象
         ///   </summary>
         private   void  CloseFileStream()
        {
             if  (br  !=   null )
            {
                br.Close();
            }
             if  (fs  !=   null )
            {
                fs.Close();
            }

            BeforeUpLoad  =   null ;
            DoUpLoad  =   null ;
            AfterUpLoad  =   null ;
            ErrorUpLoad  =   null ;
        }

         #region  IDisposable 成员
         ///   <summary>
         ///  释放对象
         ///   </summary>
         public   void  Dispose()
        {
            CloseFileStream();
        }
         #endregion
    }
}

转载于:https://www.cnblogs.com/zhangchenliang/archive/2012/04/29/2476117.html

猜你喜欢

转载自blog.csdn.net/weixin_33907511/article/details/93495133
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022