如何获取FTP服务器上文件的最后修改日期

Question

This is my code

FtpWebRequest ftpRequest = (FtpWebRequest)WebRequest.Create(FTPAddress);
ftpRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
FtpWebResponse response = (FtpWebResponse)ftpRequest.GetResponse();
StreamReader streamReader = new StreamReader(response.GetResponseStream());

List<string> directories = new List<string>();

string line = streamReader.ReadLine();
while (!string.IsNullOrEmpty(line))
{
    directories.Add(line);
    line = streamReader.ReadLine();
}

As you see, I am using ListDirectoryDetails .

For every line in the directories , this is the content:

ftp://172.28.4.7//12-22-14  01:21PM                 9075 fileName.xml

My question is how to get the time from that line? Should I parse the string? I don't think so because I read that there is the LastModified property, but I don't know how to use it.

Could you help me please?

Answer 1

Unfortunately, there's no really reliable and efficient way to retrieve modification timestamp of all files in a directory using features offered by .NET framework, as it does not support the FTP MLSD command. The MLSD command provides a listing of remote directory in a standardized machine-readable format. The command and the format is standardized by RFC 3659 .

Alternatives you can use, that are supported by .NET framework:

• ListDirectoryDetails method (the FTP LIST command) to retrieve details of all files in a directory and then you deal with FTP server specific format of the details

  DOS/Windows format: C# class to parse WebRequestMethods.Ftp.ListDirectoryDetails FTP response
  *nix format: Parsing FtpWebRequest ListDirectoryDetails line

• GetDateTimestamp method (the FTP MDTM command) to individually retrieve timestamps for each file. An advantage is that the response is standardized by RFC 3659 to YYYYMMDDHHMMSS[.sss] . A disadvantage is that you have to send a separate request for each file, what can be quite inefficient. This method uses the LastModified property that you mention:

   const string uri = "ftp://example.com/remote/path/file.txt"; FtpWebRequest request = (FtpWebRequest)WebRequest.Create(uri); request.Method = WebRequestMethods.Ftp.GetDateTimestamp; FtpWebResponse response = (FtpWebResponse)request.GetResponse(); Console.WriteLine("{0} {1}", uri, response.LastModified);

---

Alternatively you can use a 3rd party FTP client implementation that supports the modern MLSD command.

For example WinSCP .NET assembly supports that.

// Setup session options
SessionOptions sessionOptions = new SessionOptions
{
    Protocol = Protocol.Ftp,
    HostName = "example.com",
    UserName = "username",
    Password = "password",
};

using (Session session = new Session())
{
    // Connect
    session.Open(sessionOptions);

    // Get list of files in the directory
    string remotePath = "/remote/path/";
    RemoteDirectoryInfo directoryInfo = session.ListDirectory(remotePath);

    foreach (RemoteFileInfo fileInfo in directoryInfo.Files)
    {
        Console.WriteLine("{0} {1}", fileInfo.Name, fileInfo.LastWriteTime);
    }    
}

(I'm the author of WinSCP)

Answer 2

Try using this code from MS documentation:

  // Get the object used to communicate with the server.
  Uri serverUri = new Uri("ftp://mypath/myfile.txt");
  FtpWebRequest request = (FtpWebRequest)WebRequest.Create (serverUri);
  request.Method = WebRequestMethods.Ftp.GetDateTimestamp;
  FtpWebResponse response = (FtpWebResponse)request.GetResponse ();
  DateTime lastModifiedDate = response.LastModified;

http://msdn.microsoft.com/en-us/library/system.net.ftpwebresponse.lastmodified%28v=vs.110%29.aspx

You should do this for each file. To do this, it is not simple either. You have to parse the result from your directory list response.

Check how this guy do that: Extracting file names from WebRequestMethods.Ftp.ListDirectoryDetails You should be able to do a foreach on each line read.

Answer 3

This is a few years old now, but wanted to share my solution as I just had to do this.

I used the MSDN example of getting an FTP directory listing: https://docs.microsoft.com/en-us/dotnet/framework/network-programming/how-to-list-directory-contents-with-ftp

And this answer for a regex to parse the results (I actually used Nyerguds's comment): https://stackoverflow.com/a/1329074/2246411

Here's the simple class I wrote up to "reinflate" the objects from the directory listing (currently it only does the top level folder, but hopefully I can improve it and update it here: https://gist.github.com/derekantrican/9e890c06ed17ddc561d8af02e41c34c8 ):

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Text.RegularExpressions;

namespace FTPHelper
{
    public class FTPItem
    {
        public char[] Permissions { get; set; }
        public int Size { get; set; }
        public DateTime LastModified { get; set; }
        public string Name { get; set; }
        public string FullPath { get; set; }

        public override string ToString()
        {
            return Name;
        }
    }

    public class FTPDirectory : FTPItem
    {
        public FTPDirectory() { }
        public FTPDirectory(FTPItem item)
        {
            Permissions = item.Permissions;
            Size = item.Size;
            LastModified = item.LastModified;
            Name = item.Name;
            FullPath = item.FullPath;
        }

        public Lazy<List<FTPItem>> SubItems { get; set; }
    }

    public class FTPFile : FTPItem
    {
        public FTPFile() { }
        public FTPFile(FTPItem item)
        {
            Permissions = item.Permissions;
            Size = item.Size;
            LastModified = item.LastModified;
            Name = item.Name;
            FullPath = item.FullPath;
        }
    }

    public class FTPClient
    {
        private string address;
        private string username;
        private string password;

        public FTPClient(string address, string username, string password)
        {
            this.address = address.StartsWith("ftp://", StringComparison.OrdinalIgnoreCase) ? address : $"ftp://{address}";
            this.username = username;
            this.password = password;
        }

        public List<FTPItem> RetrieveDirectoryListingsFromFTP(string startingPath = null)
        {
            List<FTPItem> results = new List<FTPItem>();
            string path = !string.IsNullOrEmpty(startingPath) ? startingPath.Replace(" ", "%20") : address;
            path = !path.StartsWith(address) ? $"{address}/{path}" : path;

            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(path);
            request.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
            request.Credentials = new NetworkCredential(username, password);
            request.KeepAlive = false;
            request.UseBinary = true;
            request.UsePassive = true;

            Regex directoryListingRegex = new Regex(@"^([d-])((?:[rwxt-]{3}){3})\s+\d{1,}\s+.*?(\d{1,})\s+(\w+)\s+(\d{1,2})\s+(\d{4})?(\d{1,2}:\d{2})?\s+(.+?)\s?$",
                                    RegexOptions.Compiled | RegexOptions.Multiline | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);

            using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
            {
                using (Stream responseStream = response.GetResponseStream())
                {
                    using (StreamReader reader = new StreamReader(responseStream))
                    {
                        string line;
                        while ((line = reader.ReadLine()) != null)
                        {
                            Match match = directoryListingRegex.Match(line);

                            FTPItem item = new FTPItem
                            {
                                Permissions = match.Groups[2].Value.ToArray(),
                                Size = int.Parse(match.Groups[3].Value),
                                LastModified = DateTime.ParseExact($"{match.Groups[4]} {match.Groups[5]} {match.Groups[6]} {match.Groups[7]}",
                                                    $"MMM dd {(match.Groups[6].Value != "" ? "yyyy" : "")} {(match.Groups[7].Value != "" ? "HH:mm" : "")}",
                                                    CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal),
                                Name = match.Groups[8].Value,
                                FullPath = $"{path}/{match.Groups[8].Value.Replace(" ", "%20")}",
                            };

                            if (match.Groups[1].Value == "d")
                            {
                                FTPDirectory dir = new FTPDirectory(item);
                                dir.SubItems = new Lazy<List<FTPItem>>(() => RetrieveDirectoryListingsFromFTP(dir.FullPath));
                                results.Add(dir);
                            }
                            else
                            {
                                FTPFile file = new FTPFile(item);
                                results.Add(file);
                            }
                        }
                    }
                }
            }

            return results;
        }
    }
}