学步园

public void Process()
{
var recordCount = 1000;//每次取出邮件记录数
while (true)
{
using (var client = new Pop3Client())
{
//1、建立连接，并进行身份认证
client.Connect(server, port, useSSL);
client.Authenticate(userName, pwd);

var messageCount = client.GetMessageCount(); // 邮箱中现有邮件数
if (messageCount > recordCount)
{
messageCount = recordCount;
}
if (messageCount < 1)
{
break;
}
var listAllMsg = new List<Message>(messageCount); //用于临时保存取出的邮件

//2、取出邮件后填充至列表，每次最多recordCount封邮件
for (int i = 1; i <= messageCount; i++) //邮箱索引是基于1开始的，索引范围: [1, messageCount]
{
listAllMsg.Add(client.GetMessage(i)); //取出邮件至列表
}

//3、遍历并保存至客户端，格式为.eml
foreach (var message in listAllMsg)
{
var emlInfo = new System.IO.FileInfo(string.Format("{0}.eml", Guid.NewGuid().ToString("n")));
message.SaveToFile(emlInfo);//保存邮件为.eml格式文件
}

//4、遍历并删除
int messageNumber = 1;
foreach (var message in listAllMsg)
{
client.DeleteMessage(messageNumber); //删除邮件（本质上，在关闭连接前只是打上DELETE标签，并没有真正删除）
messageNumber++;
}

//5、断开连接，真正完成删除
client.Disconnect();

if (messageCount < recordCount)
{
break;
}
}
}
}

public void DeleteMessage(int messageNumber)
{
AssertDisposed();

ValidateMessageNumber(messageNumber);

if (State != ConnectionState.Transaction)
throw new InvalidUseException("You cannot delete any messages without authenticating yourself towards the server first");

SendCommand("DELE " + messageNumber);
}

private void SendCommand(string command)
{
// Convert the command with CRLF afterwards as per RFC to a byte array which we can write
byte[] commandBytes = Encoding.ASCII.GetBytes(command + "\r\n");

// Write the command to the server
OutputStream.Write(commandBytes, 0, commandBytes.Length);
OutputStream.Flush(); // Flush the content as we now wait for a response

// Read the response from the server. The response should be in ASCII
LastServerResponse = StreamUtility.ReadLineAsAscii(InputStream);

IsOkResponse(LastServerResponse);
}

/// <summary>
/// This is the stream used to read off the server response to a command
/// </summary>
private Stream InputStream { get; set; }

/// <summary>
/// This is the stream used to write commands to the server
/// </summary>
private Stream OutputStream { get; set; }

/// <summary>
/// Connects to a remote POP3 server
/// </summary>
/// <param name="hostname">The <paramref name="hostname"/> of the POP3 server</param>
/// <param name="port">The port of the POP3 server</param>
/// <param name="useSsl">True if SSL should be used. False if plain TCP should be used.</param>
/// <param name="receiveTimeout">Timeout in milliseconds before a socket should time out from reading. Set to 0 or -1 to specify infinite timeout.</param>
/// <param name="sendTimeout">Timeout in milliseconds before a socket should time out from sending. Set to 0 or -1 to specify infinite timeout.</param>
/// <param name="certificateValidator">If you want to validate the certificate in a SSL connection, pass a reference to your validator. Supply <see langword="null"/> if default should be used.</param>
/// <exception cref="PopServerNotAvailableException">If the server did not send an OK message when a connection was established</exception>
/// <exception cref="PopServerNotFoundException">If it was not possible to connect to the server</exception>
/// <exception cref="ArgumentNullException">If <paramref name="hostname"/> is <see langword="null"/></exception>
/// <exception cref="ArgumentOutOfRangeException">If port is not in the range [<see cref="IPEndPoint.MinPort"/>, <see cref="IPEndPoint.MaxPort"/> or if any of the timeouts is less than -1.</exception>
public void Connect(string hostname, int port, bool useSsl, int receiveTimeout, int sendTimeout, RemoteCertificateValidationCallback certificateValidator)
{
AssertDisposed();

if (hostname == null)
throw new ArgumentNullException("hostname");

if (hostname.Length == 0)
throw new ArgumentException("hostname cannot be empty", "hostname");

if (port > IPEndPoint.MaxPort || port < IPEndPoint.MinPort)
throw new ArgumentOutOfRangeException("port");

if (receiveTimeout < -1)
throw new ArgumentOutOfRangeException("receiveTimeout");

if (sendTimeout < -1)
throw new ArgumentOutOfRangeException("sendTimeout");

if (State != ConnectionState.Disconnected)
throw new InvalidUseException("You cannot ask to connect to a POP3 server, when we are already connected to one. Disconnect first.");

TcpClient clientSocket = new TcpClient();
clientSocket.ReceiveTimeout = receiveTimeout;
clientSocket.SendTimeout = sendTimeout;

try
{
clientSocket.Connect(hostname, port);
}
catch (SocketException e)
{
// Close the socket - we are not connected, so no need to close stream underneath
clientSocket.Close();

DefaultLogger.Log.LogError("Connect(): " + e.Message);
throw new PopServerNotFoundException("Server not found", e);
}

Stream stream;
if (useSsl)
{
// If we want to use SSL, open a new SSLStream on top of the open TCP stream.
// We also want to close the TCP stream when the SSL stream is closed
// If a validator was passed to us, use it.
SslStream sslStream;
if (certificateValidator == null)
{
sslStream = new SslStream(clientSocket.GetStream(), false);
}
else
{
sslStream = new SslStream(clientSocket.GetStream(), false, certificateValidator);
}
sslStream.ReadTimeout = receiveTimeout;
sslStream.WriteTimeout = sendTimeout;

// Authenticate the server
sslStream.AuthenticateAsClient(hostname);

stream = sslStream;
}
else
{
// If we do not want to use SSL, use plain TCP
stream = clientSocket.GetStream();
}

// Now do the connect with the same stream being used to read and write to
Connect(stream, stream); //In/OutputStream属性初始化
}

public Message GetMessage(int messageNumber)
{
AssertDisposed();

ValidateMessageNumber(messageNumber);

if (State != ConnectionState.Transaction)
throw new InvalidUseException("Cannot fetch a message, when the user has not been authenticated yet");

byte[] messageContent = GetMessageAsBytes(messageNumber);

return new Message(messageContent);
}

if (askOnlyForHeaders)
{
// 0 is the number of lines of the message body to fetch, therefore it is set to zero to fetch only headers
SendCommand("TOP " + messageNumber + " 0");
}
else
{
// Ask for the full message
SendCommand("RETR " + messageNumber);
}

/// <summary>
/// Tests a string to see if it is a "+OK" string.<br/>
/// An "+OK" string should be returned by a compliant POP3
/// server if the request could be served.<br/>
/// <br/>
/// The method does only check if it starts with "+OK".
/// </summary>
/// <param name="response">The string to examine</param>
/// <exception cref="PopServerException">Thrown if server did not respond with "+OK" message</exception>
private static void IsOkResponse(string response)
{
if (response == null)
throw new PopServerException("The stream used to retrieve responses from was closed");

if (response.StartsWith("+OK", StringComparison.OrdinalIgnoreCase))
return;

throw new PopServerException("The server did not respond with a +OK response. The response was: \"" + response + "\"");
}

/// <summary>
/// Save this <see cref="Message"/> to a file.<br/>
/// <br/>
/// Can be loaded at a later time using the <see cref="LoadFromFile"/> method.
/// </summary>
/// <param name="file">The File location to save the <see cref="Message"/> to. Existent files will be overwritten.</param>
/// <exception cref="ArgumentNullException">If <paramref name="file"/> is <see langword="null"/></exception>
/// <exception>Other exceptions relevant to file saving might be thrown as well</exception>
public void SaveToFile(FileInfo file)
{
if (file == null)
throw new ArgumentNullException("file");

File.WriteAllBytes(file.FullName, RawMessage);
}