从FTP响应中返回流读取器是否良好实践

Question

I have a method for FTP download file, but I do not save file locally rather I parse the file in memory through ftp response. My question is, is returning stream reader after getting ftp response stream a good practice? Because do not want to do parsing and other stuff in the same method.

var uri = new Uri(string.Format("ftp://{0}/{1}/{2}", "somevalue",     remotefolderpath, remotefilename));
var request = (FtpWebRequest)FtpWebRequest.Create(uri);
request.Credentials = new NetworkCredential(userName, password);

request.Method = WebRequestMethods.Ftp.DownloadFile;

var ftpResponse = (FtpWebResponse)request.GetResponse();
/* Get the FTP Server's Response Stream */
ftpStream = ftpResponse.GetResponseStream();
return responseStream = new StreamReader(ftpStream);

Answer 1

I see more practical returning a responseStream when you are performing an HttpWebRequest . If you are using FtpWebRequest it means you are working with files. I would read the responseStream to byte[] and return the byte file content of the downloaded file, so you can easily work with the System.IO.File classes to handle the file.

Answer 2

For me there are 2 disadvantages of using the stream directly, if you can live with them, you shouldn't waste memory or disk space.

• In this stream you can not seek to a specific position, you can only read the contents as it comes in;
• Your internet connection could suddenly drop and you will get an exception while parsing and processing your file, either split the parsing and processing or make sure your processing routine can handle the case that a file is processed for a second time (after a failure halfway through the first attempt).

To work around these issues, you could copy the stream to a MemoryStream:

using (var ftpStream = ftpResponse.GetResponseStream())    
{
   var memoryStream = new MemoryStream()
   while ((bytesRead = ftpStream.Read(buffer, 0, buffer.Length)) > 0)
   {
      memoryStream.Write(buffer, 0, bytesRead);
   }  

   memoryStream.Flush();
   memoryStream.Position = 0;
   return memoryStream;                   
}

If you are working with larger files I prefer writing it to a file, this way you minimize the memory footprint of your application:

using (var ftpStream = ftpResponse.GetResponseStream())    
{
   var fileStream = new FileStream(Path.GetTempFileName(), FileMode.CreateNew)
   while ((bytesRead = ftpStream.Read(buffer, 0, buffer.Length)) > 0)
   {
      fileStream.Write(buffer, 0, bytesRead);
   }  

   fileStream.Flush();      
   fileStream.Position = 0;
   return fileStream;
}

Answer 3

Thanks Carlos it was really helpful . I just return the byte[]

           byte[] buffer = new byte[16 * 1024];

           using (MemoryStream ms = new MemoryStream())
            {
                int read;
                while ((read = ftpStream.Read(buffer, 0, buffer.Length)) > 0)
                {
                    ms.Write(buffer, 0, read);
                }
               memoryStream=ms;
            }
         return memoryStream.ToArray();

and used byte[] in the method like this

   public async Task ParseReport(byte[] bytesRead)
    {
        Stream stream = new MemoryStream(bytesRead);
        using (StreamReader reader = new StreamReader(stream))
            {
            string line = null;
            while (null != (line = reader.ReadLine())) 
            {
              string[] values = line.Split(';');
            }
            }
        stream.Close();
    }