.net,C#,Ftp各种操作,上传,下载,删除文件,创建目录,删除目录,获得文件列表等

最新推荐文章于 2022-08-30 14:23:15 发布
最新推荐文章于 2022-08-30 14:23:15 发布
阅读量1k 收藏
点赞数
分类专栏： .NET 文章标签： .net c# buffer login exception sockets
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/talentluke/article/details/6113128
版权

using  System;
 using  System.Net;
 using  System.IO;
 using  System.Text;
 using  System.Net.Sockets;

 namespace  FTP
 {
     ///   <summary>
     ///  类描述：对FTP 操作类
     ///  作者：何火生
     ///   </summary>
     public   class  FTPFactory
     {
         #region  Arrbuite
         private   string  remoteHost, remotePath, remoteUser, remotePass, mes;
         private   int  remotePort, bytes;
         private  Socket clientSocket;

         private   int  retValue;
         private  Boolean debug;
         private  Boolean logined;
         private   string  reply;
         private   static   int  BLOCK_SIZE  =   512 ;
        Byte[] buffer  =   new  Byte[BLOCK_SIZE];
        Encoding ASCII  =  Encoding.ASCII;
         #endregion

         protected  FTPFactory()
         {
            remoteHost  =   " localhost " ;
            remotePath  =   " . " ;
            remoteUser  =   " anonymous " ;
            remotePass  =   " jaimon@school2000.co.uk " ;
            FTPSetup();
        }

         #region  构造函数        
         private   void  FTPSetup()
         {
            remotePort  =   21 ;
            debug  =   false ;
            logined  =   false ;
        }
         #endregion

         #region  getFileList
         ///   <summary>
         ///  Return a string array containing the remote directory's file list.
         ///   </summary>
         ///   <param name="mask"></param>
         ///   <returns></returns>
         public   string [] getFileList( string  mask)
         {

             if  ( ! logined)
             {
                login();
            }

            Socket cSocket  =  createDataSocket();
            sendCommand( " NLST  "   +  mask);
             if  ( ! (retValue  ==   150   ||  retValue  ==   125 ))
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

            mes  =   "" ;

             while  ( true )
             {

                 int  bytes  =  cSocket.Receive(buffer, buffer.Length,  0 );
                mes  +=  ASCII.GetString(buffer,  0 , bytes);

                 if  (bytes  <  buffer.Length)
                 {
                     break ;
                }
            }

             char [] seperator  =   {  ' /n '  } ;
             string [] mess  =  mes.Split(seperator);

            cSocket.Close();

            readReply();

             if  (retValue  !=   226 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }
             return  mess;

        }
         #endregion

         #region  getFileSize
         ///   <summary>
         ///  Return the size of a file.
         ///   </summary>
         ///   <param name="fileName"></param>
         ///   <returns></returns>
         public   long  getFileSize( string  fileName)
         {

             if  ( ! logined)
             {
                login();
            }

            sendCommand( " SIZE  "   +  fileName);
             long  size  =   0 ;

             if  (retValue  ==   213 )
             {
                size  =  Int64.Parse(reply.Substring( 4 ));
            }
             else
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

             return  size;

        }
         #endregion

         #region  login
         ///   <summary>
         ///  Login to the remote server.
         ///   </summary>
         public   void  login()
         {

            clientSocket  =   new  Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ep  =   new  IPEndPoint(Dns.GetHostEntry(remoteHost).AddressList[ 0 ], remotePort);
             try
             {
                clientSocket.Connect(ep);
            }
             catch
             {
                 // throw new IOException("Couldn't connect to remote server");;
            }

            readReply();
             if  (retValue  !=   220 )
             {
                Close();
                 // throw new IOException(reply.Substring(4));
            }
             if  (debug)
                Console.WriteLine( " USER  "   +  remoteUser);

            sendCommand( " USER  "   +  remoteUser);
             if  ( ! (retValue  ==   331   ||  retValue  ==   230 ))
             {
                cleanup();
                 // throw new IOException(reply.Substring(4));
            }

             if  (retValue  !=   230 )
             {
                 if  (debug)
                    Console.WriteLine( " PASS xxx " );

                sendCommand( " PASS  "   +  remotePass);
                 if  ( ! (retValue  ==   230   ||  retValue  ==   202 ))
                 {
                    cleanup();
                     // throw new IOException(reply.Substring(4));
                }
            }
            logined  =   true ;
            Console.WriteLine( " Connected to  "   +  remoteHost);
            ChDir(remotePath);
        }
         #endregion

         #region  setBinaryMode

         ///   <summary>
         ///  If the value of mode is true, set binary mode for downloads.
         ///  Else, set Ascii mode.
         ///   </summary>
         ///   <param name="mode"></param>
         public   void  setBinaryMode(Boolean mode)
         {

             if  (mode)
             {
                sendCommand( " TYPE I " );
            }
             else
             {
                sendCommand( " TYPE A " );
            }
             if  (retValue  !=   200 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }
        }
         #endregion         

         #region  Download
         ///   <summary>
         ///  Download a file to the Assembly's local directory,
         ///  keeping the same file name.
         ///   </summary>
         ///   <param name="remFileName"></param>
         ///   <returns></returns>
         public   bool  Download( string  remFileName)
         {
             return  Download(remFileName,  "" ,  false );
        }

         ///   <summary>
         ///  Download a remote file to the Assembly's local directory,
         ///  keeping the same file name, and set the resume flag.
         ///   </summary>
         ///   <param name="remFileName"></param>
         ///   <param name="resume"></param>
         ///   <returns></returns>
         public   bool  Download( string  remFileName, Boolean resume)
         {
             return  Download(remFileName,  "" , resume);
        }

         ///   <summary>
         ///  Download a remote file to a local file name which can include
         ///  a path. The local file name will be created or overwritten,
         ///  but the path must exist.
         ///   </summary>
         ///   <param name="remFileName"></param>
         ///   <param name="locFileName"></param>
         ///   <returns></returns>
         public   bool  Download( string  remFileName,  string  locFileName)
         {
             return  Download(remFileName, locFileName,  false );
        }


        
         ///   <summary>
         ///  Download a remote file to a local file name which can include
         ///  a path, and set the resume flag. The local file name will be
         ///  created or overwritten, but the path must exist.
         ///   </summary>
         ///   <param name="remFileName"></param>
         ///   <param name="locFileName"></param>
         ///   <param name="resume"></param>
         ///   <returns></returns>
         public   bool  Download( string  remFileName,  string  locFileName, Boolean resume)
         {

             bool  Finish  =   false ;
             bool  FileExists  =   false ;
             if  ( ! logined)
             {
                login();
            }
            setBinaryMode( true );
             try
             {
                FileInfo fileInfo  =   new  FileInfo(locFileName);
                 if  (fileInfo.Exists)
                 {
                    fileInfo.IsReadOnly  =   false ;
                    fileInfo.Delete();
                }
            }
             catch
             {
                 return   false ;
            }
             foreach  ( string  str  in  getFileList( " . " ))
             {
                 if  (str.IndexOf(remFileName.ToUpper(), StringComparison.CurrentCultureIgnoreCase)  !=   - 1 )
                 {
                    FileExists  =   true ;
                     break ;
                }
            }
             if  ( ! FileExists)
             {
                 // Console.WriteLine("文件不存在!");
                 return   false ;
            }
            Console.WriteLine( " Downloading file  "   +  remFileName  +   "  from  "   +  remoteHost  +   " / "   +  remotePath);

             if  (locFileName.Equals( "" ))
             {
                locFileName  =  remFileName;
            }

             if  ( ! File.Exists(locFileName))
             {
                Stream st  =  File.Create(locFileName);
                st.Close();
            }
            FileStream output  =   null ;
             try
             {
                output  =   new  FileStream(locFileName, FileMode.Open);
            }
             catch  (Exception ex)
             {
                Console.WriteLine(ex.Message);
                 return   false ;
            }
            Socket cSocket  =  createDataSocket();
             long  offset  =   0 ;
             if  (resume)
             {
                offset  =  output.Length;
                 if  (offset  >   0 )
                 {
                    sendCommand( " REST  "   +  offset);
                     if  (retValue  !=   350 )
                     {
                         // throw new IOException(reply.Substring(4));
                         // Some servers may not support resuming.
                        Finish  =   false ;
                        offset  =   0 ;
                    }
                }

                 if  (offset  >   0 )
                 {
                     if  (debug)
                     {
                        Console.WriteLine( " seeking to  "   +  offset);
                    }
                     long  npos  =  output.Seek(offset, SeekOrigin.Begin);
                    Console.WriteLine( " new pos= "   +  npos);
                }
            }

            sendCommand( " RETR  "   +  remFileName);
             if  ( ! (retValue  ==   150   ||  retValue  ==   125 ))
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

             while  ( true )
             {
                bytes  =  cSocket.Receive(buffer, buffer.Length,  0 );
                output.Write(buffer,  0 , bytes);
                 if  (bytes  <=   0 )
                 {
                    Finish  =   true ;
                     break ;
                }
            }

            output.Close();
             if  (cSocket.Connected)
             {
                cSocket.Close();
            }
            readReply();
             if  ( ! (retValue  ==   226   ||  retValue  ==   250 ))
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }
             return  Finish;
        }
         #endregion

         #region  Upload
         ///   <summary>
         ///  Upload a file
         ///   </summary>
         ///   <param name="fileName"></param>
         ///   <returns> Upload a file is success! </returns>
         public   bool  Upload( string  fileName)
         {
             return  Upload(fileName,  false );
        }


         ///   <summary>
         ///  Upload a file and set the resume flag.
         ///   </summary>
         ///   <param name="fileName"></param>
         ///   <param name="resume"></param>
         ///   <returns></returns>
         public   bool  Upload( string  fileName, Boolean resume)
         {
             if  ( ! logined)
             {
                login();
            }
            Socket cSocket  =  createDataSocket();
             long  offset  =   0 ;
             if  (resume)
             {
                 try
                 {
                    setBinaryMode( true );
                    offset  =  getFileSize(fileName);

                }
                 catch  (Exception)
                 {
                    offset  =   0 ;
                }
            }

             if  (offset  >   0 )
             {
                sendCommand( " REST  "   +  offset);
                 if  (retValue  !=   350 )
                 {
                     // throw new IOException(reply.Substring(4));
                     // Remote server may not support resuming.
                    offset  =   0 ;
                }
            }

            sendCommand( " STOR  "   +  Path.GetFileName(fileName));

             if  ( ! (retValue  ==   125   ||  retValue  ==   150 ))
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

             //  open input stream to read source file
            FileStream input  =   new  FileStream(fileName, FileMode.Open);
             if  (offset  !=   0 )
             {

                 if  (debug)
                 {
                    Console.WriteLine( " seeking to  "   +  offset);
                }
                input.Seek(offset, SeekOrigin.Begin);
            }

            Console.WriteLine( " Uploading file  "   +  fileName  +   "  to  "   +  remotePath);

             while  ((bytes  =  input.Read(buffer,  0 , buffer.Length))  >   0 )
             {
                cSocket.Send(buffer, bytes,  0 );
            }
            input.Close();
            Console.WriteLine( "" );
             if  (cSocket.Connected)
             {
                cSocket.Close();
            }
            readReply();
             if  ( ! (retValue  ==   226   ||  retValue  ==   250 ))
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }
             return   true ;
        }
#endregion

         #region  DeleteRemoteFile
         ///   <summary>
         ///  Delete a file from the remote FTP server.
         ///   </summary>
         ///   <param name="fileName"></param>
         public   void  DeleteRemoteFile( string  fileName)
         {

             if  ( ! logined)
             {
                login();
            }

            sendCommand( " DELE  "   +  fileName);
             if  (retValue  !=   250 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

        }
         #endregion

         #region  RenameRemoteFile
         ///   <summary>
         ///  Rename a file on the remote FTP server.
         ///   </summary>
         ///   <param name="oldFileName"></param>
         ///   <param name="newFileName"></param>
         public   void  RenameRemoteFile( string  oldFileName,  string  newFileName)
         {

             if  ( ! logined)
             {
                login();
            }

            sendCommand( " RNFR  "   +  oldFileName);

             if  (retValue  !=   350 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

             //   known problem
             //   rnto will not take care of existing file.
             //   i.e. It will overwrite if newFileName exist
            sendCommand( " RNTO  "   +  newFileName);
             if  (retValue  !=   250 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

        }
         #endregion

         #region  MkDir
         ///   <summary>
         ///  Create a directory on the remote FTP server.
         ///   </summary>
         ///   <param name="dirName"></param>
         public   void  MkDir( string  dirName)
         {

             if  ( ! logined)
             {
                login();
            }

            sendCommand( " MKD  "   +  dirName);

             if  (retValue  !=   250 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

        }
         #endregion

         #region  RmDir
         ///   <summary>
         ///  Delete a directory on the remote FTP server
         ///   </summary>
         ///   <param name="dirName"></param>
         public   void  RmDir( string  dirName)
         {

             if  ( ! logined)
             {
                login();
            }

            sendCommand( " RMD  "   +  dirName);

             if  (retValue  !=   250 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

        }
         #endregion

         #region  ChDir
         ///   <summary>
         ///  Change the current working directory on the remote FTP server.
         ///   </summary>
         ///   <param name="dirName"></param>
         public   void  ChDir( string  dirName)
         {

             if  (dirName.Equals( " . " ))
             {
                 return ;
            }

             if  ( ! logined)
             {
                login();
            }

            sendCommand( " CWD  "   +  dirName);

             if  (retValue  !=   250 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

             this .remotePath  =  dirName;

            Console.WriteLine( " Current directory is  "   +  remotePath);

        }
         #endregion

         #region  Close()
         ///   <summary>
         ///   Close the FTP connection.
         ///   </summary>
         public   void  Close()
         {

             if  (clientSocket  !=   null )
             {
                sendCommand( " QUIT " );
            }

            cleanup();
            Console.WriteLine( " Closing " );
        }
         #endregion

         #region  OTHER
         ///   <summary>
         ///  Set debug mode.
         ///   </summary>
         ///   <param name="debug"></param>
         public   void  setDebug(Boolean debug)
         {
             this .debug  =  debug;
        }

         private   void  readReply()
         {
            mes  =   "" ;
            reply  =  readLine();
            retValue  =  Int32.Parse(reply.Substring( 0 ,  3 ));
        }

         private   void  cleanup()
         {
             if  (clientSocket  !=   null )
             {
                clientSocket.Close();
                clientSocket  =   null ;
            }
            logined  =   false ;
        }
         #endregion

         #region  readLine
         private   string  readLine()
         {

             while  ( true )
             {
                bytes  =  clientSocket.Receive(buffer, buffer.Length,  0 );
                mes  +=  ASCII.GetString(buffer,  0 , bytes);
                 if  (bytes  <  buffer.Length)
                 {
                     break ;
                }
            }

             char [] seperator  =   {  ' /n '  } ;
             string [] mess  =  mes.Split(seperator);

             if  (mes.Length  >   2 )
             {
                mes  =  mess[mess.Length  -   2 ];
            }
             else
             {
                mes  =  mess[ 0 ];
            }

             if  ( ! mes.Substring( 3 ,  1 ).Equals( "   " ))
             {
                 return  readLine();
            }

             if  (debug)
             {
                 for  ( int  k  =   0 ; k  <  mess.Length  -   1 ; k ++ )
                 {
                    Console.WriteLine(mess[k]);
                }
            }
             return  mes;
        }
         #endregion

         #region  sendCommand
         private   void  sendCommand(String command)
         {

            Byte[] cmdBytes  =  Encoding.ASCII.GetBytes((command  +   " /r/n " ).ToCharArray());
            clientSocket.Send(cmdBytes, cmdBytes.Length,  0 );
            readReply();
        }
         #endregion

         #region  createDataSocket
         private  Socket createDataSocket()
         {
            sendCommand( " PASV " );
             if  (retValue  !=   227 )
             {
                 throw   new  IOException(reply.Substring( 4 ));
            }

             int  index1  =  reply.IndexOf( ' ( ' );
             int  index2  =  reply.IndexOf( ' ) ' );
             string  ipData  =  reply.Substring(index1  +   1 , index2  -  index1  -   1 );
             int [] parts  =   new   int [ 6 ];
             int  len  =  ipData.Length;
             int  partCount  =   0 ;
             string  buf  =   "" ;
             for  ( int  i  =   0 ; i  <  len  &&  partCount  <=   6 ; i ++ )
             {

                 char  ch  =  Char.Parse(ipData.Substring(i,  1 ));
                 if  (Char.IsDigit(ch))
                    buf  +=  ch;
                 else   if  (ch  !=   ' , ' )
                 {
                     throw   new  IOException( " Malformed PASV reply:  "   +  reply);
                }

                 if  (ch  ==   ' , '   ||  i  +   1   ==  len)
                 {

                     try
                     {
                        parts[partCount ++ ]  =  Int32.Parse(buf);
                        buf  =   "" ;
                    }
                     catch  (Exception)
                     {
                         throw   new  IOException( " Malformed PASV reply:  "   +  reply);
                    }
                }
            }
             string  ipAddress  =  parts[ 0 ]  +   " . "   +  parts[ 1 ]  +   " . "   +  parts[ 2 ]  +   " . "   +  parts[ 3 ];
             int  port  =  (parts[ 4 ]  <<   8 )  +  parts[ 5 ];
            Socket s  =   new  Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPEndPoint ep  =   new  IPEndPoint(Dns.GetHostEntry(ipAddress).AddressList[ 0 ], port);
             try
             {
                s.Connect(ep);
            }
             catch  (Exception)
             {
                 throw   new  IOException( " Can't connect to remote server " );
            }
             return  s;
        }
         #endregion

    }

}

talentluke
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
ftp服务器目录创建文件夹,ftp服务器目录创建文件夹
weixin_42439576的博客
08-09 3381
ftp服务器目录创建文件夹 内容精选换一换CentOS、SUSE、Euler OS、Fedora或OpenSUSE等系统使用如下命令安装nfs-utilsyum install nfs-utils设置共享文件夹打开/etc/exports，比如要把/sharedata目录设置为共享目录，可以填入如下内容：/sharedata 192.168.0.0/24(rw,sync,no_已创建文件系统，并...
C# 利用FTP自动下载xml文件后利用 FileSystemWatcher 监控目录下文件变化并自动更新数据库
kongwei521的专栏
06-30 4100
using FtpLib; using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Diagnostics; using System.IO; using System.Linq; using System.ServiceProcess;
c#删除根据路径文件
追随内心
05-12 448
private void simpleButtondel_Click(object sender, EventArgs e) { string exname = ".zip"; deleteDirFiles("E:\\delfile", exname); } //删除目录下的所有文件及文件夹 private static void deleteDirFiles(string strPath, s...
.net,C#,Ftp各种操作,上传,下载,删除文件,创建目录,删除目录,获得文件列表...
black_ben的专栏
03-27 1328
<br />using System;<br />using System.Collections.Generic;<br />using System.Text;<br />using System.Net;<br />using System.IO;<br />using System.Windows.Forms;<br /> <br />namespace ConvertData<br />{<br />    class FtpUpDown<br />    {<br />        strin
C# 文件、文件夹常规创建删除操作实例
C/C#、Android driver、STM32、Linux等等。
12-15 1373
C# 文件、文件夹常规创建删除操作实例   C#的文件操作的功能是非常丰富的。他们大多来自System.IO类，比如：File、Directory、BinaryReader、BinaryWriter、DirectoryInfo、FileStream、MemoryStream、Path、StringWriter等等。 当然，其它很多类中也包含文件操作。   这里在用C# 举几个常见实例，来说明文件、文件夹的存在查询、创建和删除的几个基本方法，以及如何浏览打开。 目录C# 文件、文件夹常规创建删除操作实例一、
Ftp各种操作,上传,下载,删除文件,创建目录,删除目录,获得文件列表等net,C#.pdf
10-07
在.NET框架中，C#提供了System.Net命名空间下的FtpWebRequest类，使得开发人员能够轻松地执行FTP操作，如上传、下载、删除文件，创建和删除目录，以及获取文件列表。 以下是一些关于C#中使用FTP的基本知识点： 1. ...
net,C#,Ftp各种操作,上传,下载,删除文件,创建目录,删除目录,获得文件列表.pdf
10-07
在.NET框架中，C#语言提供了丰富的类库用于FTP（文件传输协议）操作，使得开发者可以轻松地实现文件的上传、下载、删除以及目录管理。本文将深入探讨这些功能的实现，以帮助开发者理解如何使用C#进行FTP操作。 首先...
net,C#,Ftp各种操作,上传,下载,删除文件,创建目录,删除目录,获得文件列表等
05-20
在.NET框架中，C#语言提供了丰富的FTP操作支持，使得开发者可以方便地进行文件的上传、下载、删除以及目录的管理。下面我们将详细探讨这些知识点。 首先，要进行FTP操作，你需要使用System.Net命名空间中的...
C#Ftp文件目录展示，文件下载
06-20
综上所述，"C#Ftp文件目录展示，文件下载"项目涵盖了C#编程、WPF界面设计、FTP协议的实现等多个关键领域，是一个实用的综合案例，有助于提升开发者在桌面应用开发和网络通信方面的技能。通过学习和实践这样的项目，...
C#FTP操作：上传、下载、在服务器上创建文件夹、删除服务器上的文件
12-28
本篇将详细介绍如何使用C#进行FTP操作，包括上传文件、下载文件、在服务器上创建文件夹以及删除服务器上的文件。 首先，进行FTP操作需要使用到System.Net命名空间中的FtpWebRequest和FtpWebResponse类。以下是一些...
FtpHelper类匿名获取FTP文件
weixin_34099526的博客
09-24 170
using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Net; using System.Text; using System.Windows.Forms; using Test; namespace Test { public...
FTp上传文件，创建文件夹
最新发布
qq_41973721的博客
08-30 2539
【代码】FTp上传文件，创建文件夹。
c# ftp 判断目录是否存在和创建文件夹
weixin_30808253的博客
06-25 1090
　　工作中项目一直使用的ftp上传日志文件出现了问题，新的服务器搭建好后，日志无法上传。正好来学习一下ftp。 程序中的流程是，一个计时器，每分钟检测配置文件中本地日志文件路径下有没有日志文件，如果有就上传到服务器上去，然后把本地的文件删掉。日志以日期为单位，每天一个文件夹，之后是日志类型，按类型分文件夹。上传之前先检测服务器上是否存在该文件夹，如果不存在则创建一个文件。 下面是代...
FtpWebRequest的常用操作
Sam萨姆
07-18 5212
using System; using System.Collections.Generic; using System.Text; using System.IO; using System.Net; using System.Windows.Forms; using System.Globalization; namespace FtpTest1 {     public c
C# FTP删除文件以及文件夹
weixin_30591551的博客
07-02 2014
1.FTP文件操作类 FtpClient 1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.IO; 6 using System.Net; 7 using System.Xml....
ftp下载上传
请叫我麦兜兜儿
11-09 738
FTPClient.cs using System; using System.Collections.Generic; using System.Text; using System.Net; using System.IO; using System.Net.Sockets; namespace ftpGet { /// /// FTP Client ///
c#ftp操作全解：创建删除目录，上传下载文件，删除移动文件，文件改名，文件目录查询
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
08-12 6901
全栈工程师开发手册 （作者：栾鹏） c#教程全解 c#实现ftp的操作。包括创建删除目录，上传下载文件，删除移动文件，文件改名，文件目录查询。在调试ftp前，需要在目标主机上开启ftp功能。这里在本机上调试，目标主机也是本机。ftp信息如下表主机地址192.168.8.101，端口号使用默认21端口，开启了匿名登录。所以在代码中登陆ftp账号密码为空。测试代码static void Main
ftp 不识别中文/传送中文文件失败的原因和解决方案
热门推荐
sdgsdgwg的博客
10-28 1万+
借用了别人的c#代码做ftp，发现该ftp传输文件时不能下载带有中文名的文件。服务器是linux服务器不识别中文，客户端是win8。 这种问题是由客户端中文编码与服务器编码不一致造成的，要么让服务器识别中文编码，要么让客户端“聪明”些改变下载策略。 本人尝试前者数次，奈何水平不够，至今未能修改linux系统语言，只好尝试后者。 修改前该ftp调用方法如下： FtpWeb ftp =
C#实现FTP客户端：上传下载文件与目录操作
FTP（File Transfer Protocol）是一种用于在网络上进行文件传输的标准协议，这个客户端代码提供了基本的FTP功能，如文件上传、下载、创建目录以及目录浏览。 代码首先定义了一个名为`FTPClient`的类，包含两个构造...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值