Abrufen und Auflisten von E‑Mails vom IMAP‑Server

Abrufen und Auflisten von Nachrichten

Wie man Identifizierungsinformationen für Nachrichten in einer Mailbox erhält

Beim Abrufen und Verarbeiten von E‑Mail‑Nachrichten können Sie detaillierte Identifizierungsinformationen wie Sequenznummern und eindeutige IDs mittels der folgenden Funktionen der neuesten Version von Aspose.Email für .NET erhalten:

Aspose.Email.ImapMessageInfo Klasse: Stellt die Identifizierungsinformationen über eine Nachricht in einer IMAP‑Mailbox dar.

ImapMessageInfo.SequenceNumber Eigenschaft: Ruft die Sequenznummer der Nachricht ab.

ImapMessageInfo.UniqueId Eigenschaft: Ruft die eindeutige Kennung der Nachricht ab.

Aspose.Email.MailMessage.ItemId Eigenschaft: Stellt zusätzliche Identifizierungsinformationen über die Nachricht innerhalb der Mailbox dar.

Das folgende Code‑Snippet demonstriert, wie man Identifizierungsinformationen für Nachrichten in einer IMAP‑Mailbox erhält:

  1. Erstellen Sie eine Instanz von dem ImapClient Klasse, indem Sie die notwendigen Parameter wie IMAP‑Server‑Host, Port, E‑Mail‑Adresse, Passwort und Sicherheitsoptionen angeben.
  2. Verwenden Sie die ListMessages Methode, um eine Liste von Nachrichten aus dem Ordner "INBOX" abzurufen. Beschränken Sie die Liste auf die ersten fünf Nachrichten mit der Take(5)-Methode.
  3. Extrahieren Sie die Sequenznummern der aufgelisteten Nachrichten mithilfe der SequenceNumber Eigenschaft jeder Nachricht.
  4. Verwenden Sie die FetchMessages Methode, um die vollständigen Details der Nachrichten vom Server abzurufen, wobei die im vorherigen Schritt erhaltenen Sequenznummern verwendet werden.
  5. Durchlaufen Sie die abgerufenen Nachrichten und rufen Sie für jede Nachricht die folgenden Informationen ab und zeigen Sie sie an:
  • Die Sequenznummer der Nachricht.
  • Die Eigenschaft ItemId.SequenceNumber.
  • Der Betreff der Nachricht.
using (var client = new ImapClient(imapHost, port, emailAddress, password, securityOption))
{
    // List the first 5 messages from the inbox
    var msgs = client.ListMessages("INBOX").Take(5);
    
    // Get sequence numbers of the messages
    var seqIds = msgs.Select(t => t.SequenceNumber);
    
    // Fetch messages based on sequence numbers
    var msgsViaFetch = client.FetchMessages(seqIds);
    
    for (var i = 0; i < 5; i++)
    {
        var thisMsg = msgsViaFetch[i];
        Console.WriteLine($"Message ID: {seqIds.ElementAt(i)} SequenceNumber: {thisMsg.ItemId.SequenceNumber} Subject: {thisMsg.Subject}");
    }
}

MIME‑Nachrichten‑IDs vom Server auflisten

ImapMessageInfo bietet das MIME MessageId zur Nachrichtenidentifikation, ohne die komplette Nachricht zu extrahieren. Das folgende Code‑Snippet zeigt, wie man MIME‑MessageId auflistet.

ImapClient client = new ImapClient();
client.Host = "domain.com";
client.Username = "username";
client.Password = "password";
    
try
{
    ImapMessageInfoCollection messageInfoCol = client.ListMessages("Inbox");
    foreach (ImapMessageInfo info in messageInfoCol)
    {
        // Display MIME Message ID
        Console.WriteLine("Message Id = " + info.MessageId);
    }
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

Nachrichten vom Server auflisten

Aspose.Email bietet eine zweifache, überladene Variante von ListMessages() um eine bestimmte Anzahl von Nachrichten anhand einer Abfrage abzurufen. Das folgende Code‑Snippet zeigt, wie man Nachrichten auflistet.


imapClient.SelectFolder("Inbox");
ImapQueryBuilder builder = new ImapQueryBuilder();
MailQuery query =
	builder.Or(
	builder.Or(
	builder.Or(
	builder.Or(
	builder.Subject.Contains(" (1) "),
	builder.Subject.Contains(" (2) ")),
	builder.Subject.Contains(" (3) ")),
	builder.Subject.Contains(" (4) ")),
	builder.Subject.Contains(" (5) "));
ImapMessageInfoCollection messageInfoCol4 = imapClient.ListMessages(query, 4);
Console.WriteLine((messageInfoCol4.Count == 4) ? "Success" : "Failure");

Nachrichten rekursiv auflisten

Das IMAP‑Protokoll unterstützt das rekursive Auflisten von Nachrichten aus einem Postfachordner. Das hilft, Nachrichten auch aus Unterordnern eines Ordners aufzulisten. Das folgende Code‑Snippet zeigt, wie man Nachrichten rekursiv auflistet.

// Create an imapclient with host, user and password
ImapClient client = new ImapClient();
client.Host = "domain.com";
client.Username = "username";
client.Password = "password";
client.SelectFolder("InBox");
ImapMessageInfoCollection msgsColl = client.ListMessages(true);
Console.WriteLine("Total Messages: " + msgsColl.Count);

Nachrichten mit MultiConnection auflisten

ImapClient bietet ein UseMultiConnection Eigenschaft, die verwendet werden kann, um mehrere Verbindungen für umfangreiche Vorgänge zu erstellen. Sie können auch die Anzahl der Verbindungen festlegen, die im Multi‑Connection‑Modus verwendet werden sollen, indem Sie ImapClient.ConnectionsQuantity. Das folgende Code‑Snippet demonstriert die Verwendung des Multi‑Verbindungs‑Modus zum Auflisten von Nachrichten und vergleicht dessen Leistung mit dem Einzel‑Verbindungs‑Modus.

ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;

imapClient.SelectFolder("Inbox");
imapClient.ConnectionsQuantity = 5;
imapClient.UseMultiConnection = MultiConnectionMode.Enable;
DateTime multiConnectionModeStartTime = DateTime.Now;
ImapMessageInfoCollection messageInfoCol1 = imapClient.ListMessages(true);
TimeSpan multiConnectionModeTimeSpan = DateTime.Now - multiConnectionModeStartTime;

imapClient.UseMultiConnection = MultiConnectionMode.Disable;
DateTime singleConnectionModeStartTime = DateTime.Now;
ImapMessageInfoCollection messageInfoCol2 = imapClient.ListMessages(true);
TimeSpan singleConnectionModeTimeSpan = DateTime.Now - singleConnectionModeStartTime;
            
double performanceRelation = singleConnectionModeTimeSpan.TotalMilliseconds / multiConnectionModeTimeSpan.TotalMilliseconds;
Console.WriteLine("Performance Relation: " + performanceRelation);

Nachrichten mit Paging‑Unterstützung auflisten

In Szenarien, in denen der E-Mail-Server eine große Anzahl von Nachrichten im Postfach enthält, ist es häufig gewünscht, die Nachrichten mit Paging-Unterstützung aufzulisten oder abzurufen. Aspose.Email APIs ImapClient ermöglicht das Abrufen von Nachrichten vom Server mit Paging-Unterstützung.

///<summary>
/// This example shows the paging support of ImapClient for listing messages from the server
/// Available in Aspose.Email for .NET 6.4.0 and onwards
///</summary>
using (ImapClient client = new ImapClient("host.domain.com", 993, "username", "password"))
{
    try
    {
        int messagesNum = 12;
        int itemsPerPage = 5;
        MailMessage message = null;
        // Create some test messages and append these to server's inbox
        for (int i = 0; i < messagesNum; i++)
        {
            message = new MailMessage(
                "from@domain.com",
                "to@domain.com",
                "EMAILNET-35157 - " + Guid.NewGuid(),
                "EMAILNET-35157 Move paging parameters to separate class");
            client.AppendMessage(ImapFolderInfo.InBox, message);
        }

        // List messages from inbox
        client.SelectFolder(ImapFolderInfo.InBox);
        ImapMessageInfoCollection totalMessageInfoCol = client.ListMessages();
        // Verify the number of messages added
        Console.WriteLine(totalMessageInfoCol.Count);

        ////////////////// RETREIVE THE MESSAGES USING PAGING SUPPORT////////////////////////////////////

        List<ImapPageInfo> pages = new List<ImapPageInfo>();
        PageSettings pageSettings = new PageSettings();
        ImapPageInfo pageInfo = client.ListMessagesByPage(itemsPerPage, 0, pageSettings);
        Console.WriteLine(pageInfo.TotalCount);
        pages.Add(pageInfo);
        while (!pageInfo.LastPage)
        {
            pageInfo = client.ListMessagesByPage(itemsPerPage, pageInfo.NextPage.PageOffset, pageSettings);
            pages.Add(pageInfo);
        }
        int retrievedItems = 0;
        foreach (ImapPageInfo folderCol in pages)
            retrievedItems += folderCol.Items.Count;
        Console.WriteLine(retrievedItems);
    }
    finally
    {
    }
}

Nachrichtenanhänge auflisten

Um Informationen zu Anhängen wie Name, Größe zu erhalten, ohne die Anhangsdaten abzurufen, probieren Sie die folgenden APIs aus:

  • Aspose.Email.Clients.Imap.ImapAttachmentInfo - Stellt Anhangsinformationen dar.
  • Aspose.Email.Clients.Imap.ImapAttachmentInfoCollection - Stellt eine Sammlung von ImapAttachmentInfo Klasse.
  • Aspose.Email.Clients.Imap.ListAttachments(int sequenceNumber) – Gibt Informationen für jeden Anhang einer Nachricht zurück.

Das untenstehende Codebeispiel mit Schritten zeigt Ihnen, wie Sie die APIs verwenden:

  1. Rufen Sie die ListMessages() Methode am imapClient-Objekt. Diese Methode gibt eine ImapMessageInfoCollection zurück, die Informationen zu den Nachrichten im Postfach enthält.
  2. Iterieren Sie mit einer foreach‑Schleife über jede Nachricht in der messageInfoCollection.
  3. Rufen Sie die ListAttachments() Methode am imapClient-Objekt, wobei die SequenceNumber‑Eigenschaft des Nachrichtenobjekts als Parameter übergeben wird. Diese Methode gibt eine ImapAttachmentInfoCollection zurück, die Informationen zu den Anhängen der Nachricht enthält.
  4. Iterieren Sie mit einer foreach‑Schleife über jeden Anhang in der attachmentInfoCollection.
  5. Innerhalb der inneren Schleife können Sie auf die Informationen zu jedem Anhang über die Eigenschaften des attachmentInfo-Objekts zugreifen.
var messageInfoCollection = imapClient.ListMessages();
    
foreach (var message in messageInfoCollection)
{
    var attachmentInfoCollection = imapClient.ListAttachments(message.SequenceNumber);

    foreach (var attachmentInfo in attachmentInfoCollection)
    {
        Console.WriteLine("Attachment: {0} (size: {1})", attachmentInfo.Name, attachmentInfo.Size);
    }
}

Abrufen und Speichern von Nachrichten

Nachrichten vom Server abrufen

Die ImapClient Klasse kann Nachrichten von einem IMAP-Server abrufen und die Nachrichten im EML-Format auf einer lokalen Festplatte speichern. Die folgenden Schritte sind erforderlich, um die Nachrichten zu speichern:

  1. Erstellen Sie eine Instanz von dem ImapClient Klasse.
  2. Geben Sie im ImapClient einen Hostnamen, Port, Benutzernamen und Passwort an constructor.
  3. Wählen Sie den Ordner aus mit SelectFolder() Methode.
  4. Rufen Sie die ListMessages Methode, um das ImapMessageInfoCollection Objekt.
  5. Iterieren Sie durch die ImapMessageInfoCollection Sammlung, rufen Sie die SaveMessage() Methode und geben Sie den Ausgabepfad sowie den Dateinamen an.

Das folgende Codefragment zeigt, wie man E-Mail-Nachrichten von einem Server abruft und speichert.

// Select the inbox folder and Get the message info collection
client.SelectFolder(ImapFolderInfo.InBox);
ImapMessageInfoCollection list = client.ListMessages();

// Download each message
for (int i = 0; i < list.Count; i++)
{
    // Save the EML file locally
    client.SaveMessage(list[i].UniqueId, dataDir + list[i].UniqueId + ".eml");
}

Nachrichten in absteigender Reihenfolge abrufen

Aspose.Email bietet ImapClient.ListMessagesByPage Methode, die Nachrichten mit Paging-Unterstützung auflistet. Einige Überladungen von ImapClient.ListMessagesByPage akzeptiert PageSettings als Parameter zur Verfügung. PageSettings stellt ein AscendingSorting Eigenschaft, die, wenn sie auf false gesetzt ist, E-Mails in absteigender Reihenfolge zurückgibt.

Der folgende Beispielcode demonstriert die Verwendung von AscendingSorting Eigenschaft des PageSettings Klasse zum Ändern der Reihenfolge von E-Mails.

ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;

PageSettings pageSettings = new PageSettings { AscendingSorting = false };
ImapPageInfo pageInfo = imapClient.ListMessagesByPage(5, pageSettings);
ImapMessageInfoCollection messages = pageInfo.Items;

foreach (ImapMessageInfo message in messages)
{
    Console.WriteLine(message.Subject + " -> " + message.Date.ToString());
}

Nachrichten im MSG-Format speichern

Um E-Mails im MSG-Format zu speichern, ImapClient.FetchMessage() Methode muss aufgerufen werden. Sie gibt die Nachricht als Instanz von MailMessage Klasse. Die MailMessage.Save() Methode kann anschließend aufgerufen werden, um die Nachricht im MSG-Format zu speichern. Das folgende Codefragment zeigt, wie Nachrichten im MSG-Format gespeichert werden.

// The path to the file directory.
string dataDir = RunExamples.GetDataDir_IMAP();

// Create an imapclient with host, user and password
ImapClient client = new ImapClient("localhost", "user", "password");

// Select the inbox folder and Get the message info collection
client.SelectFolder(ImapFolderInfo.InBox);
ImapMessageInfoCollection list = client.ListMessages();

// Download each message
for (int i = 0; i < list.Count; i++)
{
    // Save the message in MSG format
    MailMessage message = client.FetchMessage(list[i].UniqueId);
    message.Save(dataDir + list[i].UniqueId + "_out.msg", SaveOptions.DefaultMsgUnicode);
}

Abgerufene Nachrichten gruppieren

ImapClient bietet ein FetchMessages Methode, die ein Iterable von Sequenznummern oder eindeutiger ID akzeptiert und eine Liste von MailMessage. Das folgende Code‑Snippet demonstriert die Verwendung von FetchMessages Methode zum Abrufen von Nachrichten mittels Sequenznummern und eindeutiger ID.

ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;

ImapMessageInfoCollection messageInfoCol = imapClient.ListMessages();
Console.WriteLine("ListMessages Count: " + messageInfoCol.Count);
int[] sequenceNumberAr = messageInfoCol.Select((ImapMessageInfo mi) => mi.SequenceNumber).ToArray();
string[] uniqueIdAr = messageInfoCol.Select((ImapMessageInfo mi) => mi.UniqueId).ToArray();

IList<MailMessage> fetchedMessagesBySNumMC = imapClient.FetchMessages(sequenceNumberAr);
Console.WriteLine("FetchMessages-sequenceNumberAr Count: " + fetchedMessagesBySNumMC.Count);

IList<MailMessage> fetchedMessagesByUidMC = imapClient.FetchMessages(uniqueIdAr);
Console.WriteLine("FetchMessages-uniqueIdAr Count: " + fetchedMessagesByUidMC.Count);

Ordner abrufen und Nachrichten rekursiv lesen

In diesem Artikel sind die meisten ImapClient Funktionen werden verwendet, um eine Anwendung zu erstellen, die alle Ordner und Unterordner rekursiv von einem IMAP-Server auflistet. Sie speichert außerdem die Nachrichten in jedem Ordner und Unterordner im MSG-Format auf einer lokalen Festplatte. Auf der Festplatte werden Ordner und Nachrichten in derselben hierarchischen Struktur wie auf dem IMAP-Server erstellt und gespeichert. Das folgende Code‑Snippet zeigt, wie Sie Nachrichten- und Unterordnerinformationen rekursiv erhalten.

public static void Run()
{
    // Create an instance of the ImapClient class
    ImapClient client = new ImapClient();

    // Specify host, username, password, Port and SecurityOptions for your client
    client.Host = "imap.gmail.com";
    client.Username = "your.username@gmail.com";
    client.Password = "your.password";
    client.Port = 993;
    client.SecurityOptions = SecurityOptions.Auto;
    try
    {
        // The root folder (which will be created on disk) consists of host and username
        string rootFolder = client.Host + "-" + client.Username;

        // Create the root folder and List all the folders from IMAP server
        Directory.CreateDirectory(rootFolder);
        ImapFolderInfoCollection folderInfoCollection = client.ListFolders();
        foreach (ImapFolderInfo folderInfo in folderInfoCollection)
        {
            // Call the recursive method to read messages and get sub-folders
            ListMessagesInFolder(folderInfo, rootFolder, client);
        }
        // Disconnect to the remote IMAP server
        client.Dispose();
    }
    catch (Exception ex)
    {
        Console.Write(Environment.NewLine + ex);
    }

    Console.WriteLine(Environment.NewLine + "Downloaded messages recursively from IMAP server.");
}

/// Recursive method to get messages from folders and sub-folders
private static void ListMessagesInFolder(ImapFolderInfo folderInfo, string rootFolder, ImapClient client)
{
    // Create the folder in disk (same name as on IMAP server)
    string currentFolder = RunExamples.GetDataDir_IMAP();
    Directory.CreateDirectory(currentFolder);

    // Read the messages from the current folder, if it is selectable
    if (folderInfo.Selectable)
    {
        // Send status command to get folder info
        ImapFolderInfo folderInfoStatus = client.GetFolderInfo(folderInfo.Name);
        Console.WriteLine(folderInfoStatus.Name + " folder selected. New messages: " + folderInfoStatus.NewMessageCount + ", Total messages: " + folderInfoStatus.TotalMessageCount);

        // Select the current folder and List messages
        client.SelectFolder(folderInfo.Name);
        ImapMessageInfoCollection msgInfoColl = client.ListMessages();
        Console.WriteLine("Listing messages....");
        foreach (ImapMessageInfo msgInfo in msgInfoColl)
        {
            // Get subject and other properties of the message
            Console.WriteLine("Subject: " + msgInfo.Subject);
            Console.WriteLine("Read: " + msgInfo.IsRead + ", Recent: " + msgInfo.Recent + ", Answered: " + msgInfo.Answered);

            // Get rid of characters like ? and :, which should not be included in a file name and Save the message in MSG format
            string fileName = msgInfo.Subject.Replace(":", " ").Replace("?", " ");
            MailMessage msg = client.FetchMessage(msgInfo.SequenceNumber);
            msg.Save(currentFolder + "\\" + fileName + "-" + msgInfo.SequenceNumber + ".msg", SaveOptions.DefaultMsgUnicode);
        }
        Console.WriteLine("============================\n");
    }
    else
    {
        Console.WriteLine(folderInfo.Name + " is not selectable.");
    }

    try
    {
        // If this folder has sub-folders, call this method recursively to get messages
        ImapFolderInfoCollection folderInfoCollection = client.ListFolders(folderInfo.Name);
        foreach (ImapFolderInfo subfolderInfo in folderInfoCollection)
        {
            ListMessagesInFolder(subfolderInfo, rootFolder, client);
        }
    }
    catch (Exception) { }            
}

Spezielle Nachrichteninformationen verarbeiten

Zusätzliche Parameter als Zusammenfassungsinformationen abrufen

using (ImapClient client = new ImapClient("host.domain.com", "username", "password"))
{
    MailMessage message = new MailMessage("from@domain.com", "to@doman.com", "EMAILNET-38466 - " + Guid.NewGuid().ToString(), "EMAILNET-38466 Add extra parameters for UID FETCH command");

    // append the message to the server
    string uid = client.AppendMessage(message);

    // wait for the message to be appended
    Thread.Sleep(5000);

    // Define properties to be fetched from server along with the message
    string[] messageExtraFields = new string[] { "X-GM-MSGID", "X-GM-THRID" };

    // retreive the message summary information using it's UID
    ImapMessageInfo messageInfoUID = client.ListMessage(uid, messageExtraFields);

    // retreive the message summary information using it's sequence number
    ImapMessageInfo messageInfoSeqNum = client.ListMessage(1, messageExtraFields);

    // List messages in general from the server based on the defined properties
    ImapMessageInfoCollection messageInfoCol = client.ListMessages(messageExtraFields);

    ImapMessageInfo messageInfoFromList = messageInfoCol[0];

    // verify that the parameters are fetched in the summary information
    foreach (string paramName in messageExtraFields)
    {
        Console.WriteLine(messageInfoFromList.ExtraParameters.ContainsKey(paramName));
        Console.WriteLine(messageInfoUID.ExtraParameters.ContainsKey(paramName));
        Console.WriteLine(messageInfoSeqNum.ExtraParameters.ContainsKey(paramName));
    }
}

List-Unsubscribe-Header-Informationen abrufen

Der List-Unsubscribe-Header enthält die URL zum Abmelden von E-Mail-Listen, z. B. Werbung, Newsletter usw. Um den List-Unsubscribe-Header zu erhalten, verwenden Sie die ListUnsubscribe Eigenschaft des ImapMessageInfo Klasse. Das folgende Beispiel zeigt die Verwendung von ListUnsubscribe Eigenschaft, um den List-Unsubscribe-Header abzurufen.

ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;

ImapMessageInfoCollection messageInfoCol = imapClient.ListMessages();
foreach (ImapMessageInfo imapMessageInfo in messageInfoCol)
{
    Console.WriteLine("ListUnsubscribe Header: " + imapMessageInfo.ListUnsubscribe);
}
Verbindung zum IMAP‑Server Nachrichten vom IMAP‑Server in C# filtern