Wie man IMAP‑Verbindungen in C# herstellt

Auflisten von IMAP‑Server‑Erweiterungen

von Aspose.Email ImapClient ermöglicht das Abrufen der Server‑Erweiterungen, die ein Server unterstützt, wie IDLE, UNSELECT, QUOTA usw. Dies hilft, die Verfügbarkeit einer Erweiterung zu erkennen, bevor der Client für diese Funktionalität verwendet wird. Die GetCapabilities() Methode gibt die unterstützten Erweiterungstypen als String‑Array zurück. Das folgende Codefragment zeigt, wie man Erweiterungen abruft.

Standard‑IMAP‑Verbindung

Die ImapClient Klasse ermöglicht Anwendungen, IMAP‑Postfächer über das IMAP‑Protokoll zu verwalten. Die ImapClient Klasse wird verwendet, um sich mit IMAP‑Mail‑Servern zu verbinden und E‑Mails in den IMAP‑Ordnern zu verwalten. Um sich mit einem IMAP‑Server zu verbinden

Erstellen Sie eine Instanz von dem ImapClient Klasse.
Hostname, Benutzernamen und Passwort angeben im ImapClient constructor.

Hinweis: Passwortrichtlinien müssen den Anforderungen des Servers entsprechen. Der E‑Mail‑Client fügt keine Passwortrichtlinien hinzu.

Sobald das ImapClient Instanz wird initialisiert, der nächste Aufruf einer Operation mit dieser Instanz stellt die Verbindung zum Server her. Das folgende Code‑Snippet zeigt, wie man mit den obigen Schritten eine Verbindung zu einem IMAP‑Server herstellt.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create an imapclient with host, user and password
ImapClient client = new ImapClient("localhost", "user", "password");

SSL‑aktivierte IMAP‑Verbindung

Verbindung mit IMAP‑Server beschrieb, wie man in vier einfachen Schritten eine Verbindung zu einem IMAP‑Server herstellt:

Erstellen Sie eine Instanz von dem ImapClient Klasse.
Hostname, Benutzernamen und Passwort angeben.
Port angeben.
Geben Sie die Sicherheitsoptionen an.

Der Vorgang zum Verbinden mit einem SSL‑aktivierten IMAP‑Server ist ähnlich, erfordert jedoch das Setzen einiger weiterer Eigenschaften:

Festlegen Sicherheitsoptionen zu SSLImplicit.

Das folgende Code‑Snippet zeigt, wie man

Legen Sie einen Benutzernamen, ein Passwort und einen Port fest.
Sicherheitsoption festlegen.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Create an instance of the ImapClient class
ImapClient client = new ImapClient("imap.domain.com", 993, "user@domain.com", "pwd");
            
// Set the security mode to implicit
client.SecurityOptions = SecurityOptions.SSLImplicit;

Proxy‑Verbindungs‑Setup

Verbindung zu einem Server über Proxy herstellen

Proxy‑Server werden häufig verwendet, um mit der Außenwelt zu kommunizieren. In solchen Fällen können E‑Mail‑Clients nicht über das Internet kommunizieren, ohne die Proxy‑Adresse anzugeben. Aspose.Email unterstützt die Versionen 4, 4a und 5 des SOCKS‑Proxy‑Protokolls. Dieser Artikel liefert ein funktionierendes Beispiel zum Zugriff auf das Postfach über einen Proxy‑Mail‑Server. So greifen Sie über einen Proxy‑Server auf das Postfach zu:

Initialisieren SocksProxy mit den erforderlichen Angaben, also Proxy‑Adresse, Port und SOCKS‑Version.
Initialisieren ImapClient mit Hostadresse, Benutzernamen, Passwort und weiteren Einstellungen.
Setzen Sie die des Clients SocksProxy Eigenschaft des Clients zu SocksProxy Objekt, das oben erstellt wurde.

Das folgende Code‑Snippet zeigt, wie man ein Postfach über einen Proxy‑Server abruft.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Connect and log in to IMAP and set SecurityOptions
ImapClient client = new ImapClient("imap.domain.com", "username", "password");
client.SecurityOptions = SecurityOptions.Auto;
            
string proxyAddress = "192.168.203.142"; // proxy address
int proxyPort = 1080; // proxy port
SocksProxy proxy = new SocksProxy(proxyAddress, proxyPort, SocksVersion.SocksV5);

// Set the proxy
client.Proxy = proxy;
           
try
{
    client.SelectFolder("Inbox");
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

Verbindung zum Server über HTTP‑Proxy

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
HttpProxy proxy = new HttpProxy("18.222.124.59", 8080);
using (ImapClient client = new ImapClient("imap.domain.com", "username", "password"))
{
    client.Proxy = proxy;
    client.SelectFolder("Inbox");
}

Verbindung im Nur‑Lese‑Modus

Die ImapClient Klasse stellt ein ReadOnly Eigenschaft, die, wenn sie auf true gesetzt wird, anzeigt, dass keine Änderungen am permanenten Zustand des Postfachs vorgenommen werden dürfen. Das folgende Codebeispiel demonstriert die Verwendung von ImapClient.ReadOnly Eigenschaft. Sie ermittelt die Anzahl ungelesener Nachrichten, holt dann eine Nachricht und ermittelt anschließend erneut die Anzahl ungelesener Nachrichten im Nur‑Lese‑Modus. Die Anzahl bleibt gleich, was zeigt, dass der permanente Zustand des Postfachs nicht verändert wurde.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
ImapClient imapClient = new ImapClient();
imapClient.Host = "<HOST>";
imapClient.Port = 993;
imapClient.Username = "<USERNAME>";
imapClient.Password = "<PASSWORD>";
imapClient.SupportedEncryption = EncryptionProtocols.Tls;
imapClient.SecurityOptions = SecurityOptions.SSLImplicit;

ImapQueryBuilder imapQueryBuilder = new ImapQueryBuilder();
imapQueryBuilder.HasNoFlags(ImapMessageFlags.IsRead); /* get unread messages. */
MailQuery query = imapQueryBuilder.GetQuery();

imapClient.ReadOnly = true;
imapClient.SelectFolder("Inbox");
ImapMessageInfoCollection messageInfoCol = imapClient.ListMessages(query);
Console.WriteLine("Initial Unread Count: " + messageInfoCol.Count());
if (messageInfoCol.Count() > 0)
{
    imapClient.FetchMessage(messageInfoCol[0].SequenceNumber);

    messageInfoCol = imapClient.ListMessages(query);
    // This count will be equal to the initial count
    Console.WriteLine("Updated Unread Count: " + messageInfoCol.Count());
}
else
{
    Console.WriteLine("No unread messages found");
}

CRAM‑MD5‑Authentifizierungs‑Setup

Für sichere Authentifizierung und Zugriff auf den E‑Mail‑Server bietet Aspose.Email für .NET eine CRAM‑MD5‑Authentifizierungsmethode. Das folgende Code‑Snippet zeigt, wie es mit dem ImapClient funktioniert:

imapClient.AllowedAuthentication = ImapKnownAuthenticationType.CramMD5;

Timeouts für IMAP‑Operationen festlegen

Jeder E‑Mail‑Vorgang benötigt je nach vielen Faktoren (Netzwerkverzögerungen, Datenmenge, Server‑Leistung usw.) gewisse Zeit. Sie können für alle E‑Mail‑Vorgänge einen Timeout festlegen. Das nachstehende Code‑Beispiel zeigt, wie Sie das mit dem Timeout Eigenschaft. Hinweis: Sie sollten keine großen Werte setzen, um lange Wartezeiten in Ihrer Anwendung zu vermeiden.

Betriebs‑Timeout konfigurieren

using (ImapClient imapClient = new ImapClient("host", 993, "username", "password", SecurityOptions.SSLImplicit))
{
    imapClient.Timeout = 60000; // 60 seconds

    // some code...
}

Begrüßungs‑Timeout einschränken

Der IMAP‑Client kann den automatischen Modus verwenden, um eine Verbindung herzustellen. In diesem Modus durchläuft der IMAP‑Client alle möglichen Verbindungsparameter, bis die Verbindung aufgebaut ist. Ein IMAP‑Server sendet bei einer korrekten Verbindung eine Begrüßungszeichenkette an den Client. Server können implizite oder explizite (START TLS) SSL/TLS‑Verbindungsinitialisierung verwenden. Wenn der Verbindungsmodus nicht übereinstimmt (z. B. wartet der Server auf eine implizite SSL‑Verbindung, der Client jedoch versucht, eine nicht gesicherte oder explizite SSL‑Verbindung herzustellen), sendet der Server keine Begrüßungszeichenkette und der Benutzer wartet lange, bis das Timeout die Begrüßungszeichenkette erreicht, woraufhin der Client zur nächsten Verbindungsoption wechselt. Um dieses Problem zu vermeiden, wurde die Eigenschaft GreetingTimeout eingeführt. Diese Eigenschaft ermöglicht es, das Timeout für die Begrüßungszeichenkette festzulegen und die Zeit für die automatische Verbindungsherstellung zu verkürzen.

using (ImapClient client = new ImapClient("localhost", 993, "username", "password"))
{
    client.GreetingTimeout = 4000;
    client.SelectFolder(ImapFolderInfo.InBox);
}

Verwendung kryptographischer Protokolle mit IMAP

Aspose.Email unterstützt die kryptografischen Protokolle SSL (veraltet) und TLS, um Kommunikationssicherheit zu bieten. Sie können die kryptografische Verschlüsselung aktivieren, um den Datenaustausch zwischen Ihrer Anwendung und den Mail‑Servern zu schützen.

HINWEIS: Sie sollten nur jene Versionen des Protokolls festlegen, die vom .NET‑Framework unterstützt werden. Wenn einige Versionen des kryptografischen Protokolls von Ihrer aktuellen .NET‑Framework‑Version nicht unterstützt werden, werden sie ignoriert und übersprungen. In diesem Fall werden keine Ausnahmen erzeugt. Bitte verwenden Sie SetSupportedEncryptionUnsafe Methode, wenn Sie die Protokolle ohne Kompatibilitätsprüfungen festlegen möchten.

Das untenstehende Codebeispiel zeigt, wie Sie TLS 1.3 für ImapClient Klasseninstanz.

using (ImapClient imapClient = new ImapClient("host", 993, "username", "password", SecurityOptions.SSLImplicit))
{
    imapClient.SupportedEncryption = EncryptionProtocols.Tls13;

    // some code...
}

Falls ein angegebenes Verschlüsselungsprotokoll in der aktuellen Version des .NET‑Frameworks nicht unterstützt wird, besteht der Unterschied im Verhalten zwischen SetSupportedEncryptionUnsafe Methode und SupportedEncryption Eigenschaft ist wie folgt:

Wenn SupportedEncryption Wird die Eigenschaft verwendet, reduziert der E‑Mail‑Client das Verschlüsselungsprotokoll auf ein unterstütztes Niveau.
Wenn SetSupportedEncryptionUnsafe Wird die Methode verwendet, wirft der E‑Mail‑Client Ausnahmen.

Verwendung des IMAP‑IDLE‑Befehls

Aspose.Email‑APIs ImapClient bietet die Möglichkeit, eine Verbindung zum Server zu öffnen und auf das Eintreffen einer E‑Mail‑Nachricht zu warten. Dadurch wird mehrfaches Abfragen des Servers nach eingehenden E‑Mails vermieden. Das folgende Code‑Snippet demonstriert, wie man die Aspose.Email‑Bibliothek verwendet, um einen IMAP‑Posteingang auf neue und gelöschte Nachrichten zu überwachen und basierend auf diesen Ereignissen spezifische Aktionen auszuführen:

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
// Connect and log in to IMAP 
ImapClient client = new ImapClient("imap.domain.com", "username", "password");

ManualResetEvent manualResetEvent = new ManualResetEvent(false);
ImapMonitoringEventArgs eventArgs = null;
client.StartMonitoring(delegate(object sender, ImapMonitoringEventArgs e)
{
    eventArgs = e;
    manualResetEvent.Set();
});
Thread.Sleep(2000);
SmtpClient smtpClient = new SmtpClient("exchange.aspose.com", "username", "password");
smtpClient.Send(new MailMessage("from@aspose.com", "to@aspose.com", "EMAILNET-34875 - " + Guid.NewGuid(), "EMAILNET-34875 Support for IMAP idle command"));
manualResetEvent.WaitOne(10000);
manualResetEvent.Reset();
Console.WriteLine(eventArgs.NewMessages.Length);
Console.WriteLine(eventArgs.DeletedMessages.Length);
client.StopMonitoring("Inbox");
smtpClient.Send(new MailMessage("from@aspose.com", "to@aspose.com", "EMAILNET-34875 - " + Guid.NewGuid(), "EMAILNET-34875 Support for IMAP idle command"));
manualResetEvent.WaitOne(5000);

Das folgende Beispiel zeigt, wie man asynchrones Monitoring für neue E‑Mail‑Nachrichten einrichtet:

var client = = new ImapClient("imap.domain.com", "username", "password");

//anySuccess is a flag to prevent infinite Client.ResumeMonitoring calls
var anySuccess = false;
await client.StartMonitoringAsync(OnNewMessagesCallback, OnErrorCallback);

void OnErrorCallback(object eventSender, ImapMonitoringErrorEventArgs errorEventArguments)
{
    //The exception can be handled here
    Logger.Debug.Write(
        $"An error occured while folder monitoring: {errorEventArguments.FolderName}",
        errorEventArguments.Error);
    //IMAP folder monitoring is stopped on any error. Here is an example
    //of resuming after that.
    if (!anySuccess) return;
    anySuccess = false;
    //Make sure you use ResumeMonitoring instead of StartMonitoring here
    //to prevent missing any emails between the error handling and resuming.
    client.ResumeMonitoring(OnNewMessagesCallback, OnErrorCallback,
        errorEventArguments.MonitoringState);
}

void OnNewMessagesCallback(object sender, ImapMonitoringEventArgs successEventArgs)
{
    anySuccess = true;
    //Use successEventArgs.NewMessages to handle new messages
    //Use successEventArgs.DeletedMessages to handle deleted messages
}

Unterstützung für IMAP‑Erweiterungen

Aspose.Email API bietet Unterstützung für IMAP‑Erweiterungen. Die folgenden IMAP‑Erweiterungen werden derzeit von der API unterstützt. Diese IMAP‑Erweiterungen werden nicht von allen Servern unterstützt.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
using (ImapClient client = new ImapClient("imap.gmail.com", 993, "username", "password"))
{
    // Set SecurityOptions
    client.SecurityOptions = SecurityOptions.Auto;
    Console.WriteLine(client.IdSupported.ToString());

    ImapIdentificationInfo serverIdentificationInfo1 = client.IntroduceClient();
    ImapIdentificationInfo serverIdentificationInfo2 = client.IntroduceClient(ImapIdentificationInfo.DefaultValue);

    // Display ImapIdentificationInfo properties
    Console.WriteLine(serverIdentificationInfo1.ToString(), serverIdentificationInfo2);
    Console.WriteLine(serverIdentificationInfo1.Name);
    Console.WriteLine(serverIdentificationInfo1.Vendor);
    Console.WriteLine(serverIdentificationInfo1.SupportUrl);
    Console.WriteLine(serverIdentificationInfo1.Version);
}

Erweiterter LIST‑Befehl von IMAP4

Das folgende Code‑Snippet zeigt, wie der erweiterte LIST‑Befehl von IMAP4 verwendet wird.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-.NET
using (ImapClient client = new ImapClient("imap.gmail.com", 993, "username", "password"))
{
    ImapFolderInfoCollection folderInfoCol = client.ListFolders("*");
    Console.WriteLine("Extended List Supported: " + client.ExtendedListSupported);
    foreach (ImapFolderInfo folderInfo in folderInfoCol)
    {
        switch (folderInfo.Name)
        {
            case "[Gmail]/All Mail":
                Console.WriteLine("Has Children: " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Bin":
                Console.WriteLine("Bin has children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Drafts":
                Console.WriteLine("Drafts has children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Important":
                Console.WriteLine("Important has Children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Sent Mail":
                Console.WriteLine("Sent Mail has Children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Spam":
                Console.WriteLine("Spam has Children? " + folderInfo.HasChildren);
                break;
            case "[Gmail]/Starred":
                Console.WriteLine("Starred has Children? " + folderInfo.HasChildren);
                break;
        }
    }
}

Verwalten von Nachrichten auf dem IMAP‑Server