我有一个任务，我被它卡住了[类，数组，循环]

我已经提供了一个与你的例子长度相匹配的答案。它是彻底的，因为你提供了很好的证据来证明你已经尝试过了。我将在源代码区域下面激励一些决策。

class Letter
{
    public const char FieldSeparator = ';';
    public const char TimeFieldSeparator = ':'; //WARNING: Tweaking this will result in you needing to change .ToString() calls on TimeSpan and DateTime manually
    public DateTime SendDate { get; private set; }
    public DateTime EstimatedReceivedDate => SendDate + (Server != null ? TimeSpan.FromSeconds((double)Size / Server.TransferRate) : TimeSpan.MaxValue);
    //Traditionally, the server would record this data when it receives it
    public string Sender { get; private set; } //These should be fundamental User / Account classes
    public string Receiver { get; private set; }
    public Server Server { get; private set; }
    public int Size { get; private set; } //We assume this is the size in bytes
    public Letter(DateTime sendDate, string sender, string receiver, Server server, int size)
    {
        SendDate = sendDate;
        Sender = sender;
        Receiver = receiver;
        Server = server;
        Size = size;
    }
    public static Letter Deserialize(string s, IList<Server> servers)
    {
        if (string.IsNullOrEmpty(s)) throw new ArgumentException("Invalid argument s: Cannot parse from null or empty string");
        var split = s.Split(FieldSeparator);
        if (split.Length != 5) throw new ArgumentException("Malformed string s! Format: Time " + FieldSeparator + "Sender" + FieldSeparator + "Receiver" + FieldSeparator + "Server" + FieldSeparator + "Size");
        var date = DateTime.Today;
        var timeSplit = split[0].Split(TimeFieldSeparator);
        if (timeSplit.Length != 3) throw new ArgumentException("Malformed time in s! Format: HH" + TimeFieldSeparator + "mm" + TimeFieldSeparator + "ss");
        int hour;
        if (!int.TryParse(timeSplit[0], out hour)) throw new ArgumentException("Could not parse hour from string: " + timeSplit[0]);
        int minute;
        if (!int.TryParse(timeSplit[1], out minute)) throw new ArgumentException("Could not parse minute from string: " + timeSplit[1]);
        int second;
        if (!int.TryParse(timeSplit[2], out second)) throw new ArgumentException("Could not parse second from string: " + timeSplit[2]);
        date = date + new TimeSpan(0, hour, minute, second);
        if (servers == null || servers.Count == 0) throw new ArgumentException("Invalid list of servers passed. No servers mean no message could have been sent.");
        Server server;
        try
        {
            server = servers.First(serv => serv.Name == split[3]);
        }
        catch (InvalidOperationException)
        {
            throw new ArgumentException("Could not parse server from string: " + split[3] + ". No such server was present in the list passed to the function.");
        }
        int size;
        if (!int.TryParse(split[4], out size)) throw new ArgumentException("Could not parse size from string: " + split[4]);
        var letter = new Letter(date, split[1], split[2], server, size);
        server.Letters.Add(letter);
        return letter;
    }
    public string Serialize(Server s)
    {
        return s.ToString();
    }
    public override string ToString()
    {
        return SendDate.ToString("HH:mm:ss") + FieldSeparator + Sender + FieldSeparator + Receiver + FieldSeparator + Server.Name + FieldSeparator + Size;
    }
}
class Server
{
    public const char FieldSeparator = ';';
    public string Name { get; private set; }
    public int TransferRate { get; set; } //Bytes/Sec
    public IList<Letter> Letters { get; private set; }
    public int BytesReceived => Letters.Sum(l => l.Size);
    public int TotalTransferTime => BytesReceived/TransferRate; 
    //Optionally use public int BytesReceived { get { return Letters.Sum(l => l.Size); } } if C# < 6, this applies to all of these
    public DateTime LastLetterReceiveDate => Letters.Max(letter => letter.EstimatedReceivedDate > DateTime.Now ? DateTime.MinValue : letter.EstimatedReceivedDate);
    public Server(string name, int transferRate, IList<Letter> letters)
    {
        Name = name;
        TransferRate = transferRate;
        Letters = letters;
    }
    public Server(string name, int transferRate, params Letter[] letters)
    {
        Name = name;
        TransferRate = transferRate;
        Letters = new List<Letter>(letters.Length);
        foreach (var letter in letters)
            Letters.Add(letter);
    }
    public static Server Deserialize(string s)
    {
        if (string.IsNullOrEmpty(s)) throw new ArgumentException("Invalid argument s: Cannot parse from null or empty string");
        var split = s.Split(FieldSeparator);
        if (split.Length != 2) throw new ArgumentException("Malformed string s! Format: Name " + FieldSeparator + "TransferRate");
        int transferRate;
        if (!int.TryParse(split[1], out transferRate)) throw new ArgumentException("Could not parse transfer rate from string: " + split[1]);
        return new Server(split[0], transferRate);
    }
    public string Serialize(Server s)
    {
        return s.ToString();
    }
    public override string ToString()
    {
        return Name + FieldSeparator + TransferRate;
    }
    public string Summary()
    {
        return Name + FieldSeparator + Letters.Count + FieldSeparator + BytesReceived + FieldSeparator + TotalTransferTime + FieldSeparator + (DateTime.Now - LastLetterReceiveDate).ToString("hh:mm:ss");
    }
}
class Program
{
    public static char EntrySeparator = ' ';
    static void Main(string[] args)
    {
        if (!File.Exists(Path.Combine(Environment.CurrentDirectory, "servers.scv"))) throw new FileNotFoundException("Cannot find file servers.scv file at path" + Path.Combine(Environment.CurrentDirectory, "servers.scv"));
        var serversscv = File.ReadAllText(Path.Combine(Environment.CurrentDirectory, "servers.scv"));
        if (!File.Exists(Path.Combine(Environment.CurrentDirectory, "letters.csv"))) throw new FileNotFoundException("Cannot find file servers.scv file at path" + Path.Combine(Environment.CurrentDirectory, "servers.scv"));
        var letterscsv = File.ReadAllText(Path.Combine(Environment.CurrentDirectory, "servers.scv"));

        var serversSplit = serversscv.Split(EntrySeparator);
        var lettersSplit = letterscsv.Split(EntrySeparator);
        var servers = new List<Server>(serversSplit.Length);
        var letters = new List<Letter>(lettersSplit.Length);
        servers.AddRange(serversSplit.Select(Server.Deserialize));
        letters.AddRange(lettersSplit.Select(letterString => Letter.Deserialize(letterString, servers)));
        var oldServers = servers.Where(server => (DateTime.Now - server.LastLetterReceiveDate).TotalHours >= 1).Aggregate(string.Empty, (current, oldServer) => current + oldServer);
        var file = File.CreateText(Path.Combine(Environment.CurrentDirectory, "oldservers.csv"));
        file.WriteLine(oldServers); //Async possible if you're doing a continouous process (ie server does this parsing)
    }
}

现在至于其中的一些动机。

发送时间，发件人，接收者，服务器名称，信件大小

创建一个包含这些的简单类，这就是结果'Letter'。

服务器名称，速度(bits/second)

我以为你指的是字节每秒，所以我注释了一下。这个信息使类'Server'。

通过发件人发送电子邮件的时间，您可以计算电子邮件何时完全传输(发送)到服务器。如果(信件的)转帐在下一个小时内全部转帐，那么这个小时也算。

我接受了这个和你关于如何计算收到日期的解释，并制作了一个包含实际完成的转移日期的小属性。这导致'EstimatedReceivedDate'。

序列化是相当直接的，因为您几乎是自己管理的。我为您标准化了它，以便将来易于使用和扩展。还有什么……让我们来看看。是的，服务器有一个字母列表因为他们经常使用字母信息。解析过程中的信息传递是在Letter的转换方法中完成的，但也有更好的方法。一个非常可移植的方法是在Letter请求服务器时添加一个回调，然后将正确的服务器提供给它。

如果有什么不寻常的，你不明白或想要一个动机以外的以上，请随意评论。我觉得剩下的已经很明显了，不需要任何额外的背景。

我会补充一点，一些空检查是无用的，一些属性被评估的次数比它们必须的要多，所以如果你需要约束"性能"，请在写问题时添加。