Comment établir des connexions IMAP en C#

Liste des extensions du serveur IMAP

Aspose.Email ImapClient vous permet de récupérer les extensions serveur qu’un serveur prend en charge telles que IDLE, UNSELECT, QUOTA, etc. Cela aide à identifier la disponibilité d’une extension avant d’utiliser le client pour cette fonctionnalité particulière. Le GetCapabilities() la méthode renvoie les types d’extensions pris en charge sous forme de tableau de chaînes. Le fragment de code suivant montre comment récupérer les extensions.

Connexion IMAP standard

Le ImapClient la classe permet aux applications de gérer les boîtes aux lettres IMAP en utilisant le protocole IMAP. Le ImapClient la classe est utilisée pour se connecter aux serveurs de messagerie IMAP et gérer les courriels dans les dossiers IMAP. Pour se connecter à un serveur IMAP

  1. Créez une instance de la ImapClient classe.
  2. Spécifier le nom d’hôte, le nom d’utilisateur et le mot de passe dans le Constructeur ImapClient.

Remarque : les restrictions de mot de passe doivent respecter les exigences du serveur. Le client e‑mail n’ajoute pas de restrictions de mot de passe.

Une fois le ImapClient l’instance est initiée, le prochain appel à toute opération utilisant cette instance se connectera au serveur. Le fragment de code suivant vous montre comment se connecter à un serveur IMAP en suivant les étapes ci‑dessus.

// 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");

Connexion IMAP avec SSL activé

Connexion avec le serveur IMAP décrit comment se connecter à un serveur IMAP en quatre étapes simples :

  1. Créez une instance de la ImapClient classe.
  2. Spécifier le nom d’hôte, le nom d’utilisateur et le mot de passe.
  3. Spécifier le port.
  4. Spécifiez les options de sécurité.

Le processus de connexion à un serveur IMAP avec SSL activé est similaire mais nécessite de définir quelques propriétés supplémentaires :

Le fragment de code suivant montre comment

  1. Définir un nom d’utilisateur, un mot de passe et le port.
  2. Définir l’option de sécurité.
// 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;

Configuration de la connexion proxy

Connexion au serveur via un proxy

Les serveurs proxy sont couramment utilisés pour communiquer avec l’extérieur. Dans ces cas, les clients de messagerie ne peuvent pas communiquer sur Internet sans spécifier l’adresse du proxy. Aspose.Email prend en charge les versions 4, 4a et 5 du protocole proxy SOCKS. Cet article fournit un exemple fonctionnel d’accès à la boîte aux lettres en utilisant un serveur proxy de messagerie. Pour accéder à la boîte aux lettres via un serveur proxy :

  1. Initialiser SocksProxy avec les informations requises, c’est-à-dire l’adresse du proxy, le port et la version SOCKS.
  2. Initialiser ImapClient avec l’adresse de l’hôte, le nom d’utilisateur, le mot de passe et tout autre paramètre.
  3. Définir le client SocksProxy propriété du client à la SocksProxy objet créé ci‑dessus.

Le fragment de code suivant vous montre comment récupérer une boîte aux lettres via un serveur proxy.

// 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);
}

Connexion au serveur via proxy HTTP

// 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");
}

Connexion en mode lecture seule

Le ImapClient la classe fournit un ReadOnly propriété qui, lorsqu’elle est définie sur true, indique qu’aucune modification ne doit être apportée à l’état permanent de la boîte aux lettres. L’exemple de code suivant montre l’utilisation de ImapClient.ReadOnly propriété. Elle obtient le nombre de messages non lus, récupère ensuite un message puis obtient à nouveau le nombre de messages non lus en mode lecture seule. Le nombre de messages non lus reste le même, indiquant que l’état permanent de la boîte aux lettres n’a pas été modifié.

// 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");
}

Configuration de l’authentification CRAM-MD5

Pour une authentification sécurisée et un accès au serveur e‑mail, Aspose.Email pour .NET propose une méthode d’authentification CRAM-MD5. Le fragment de code suivant vous montre comment cela fonctionne avec ImapClient :

imapClient.AllowedAuthentication = ImapKnownAuthenticationType.CramMD5;

Définir les délais d’attente pour les opérations IMAP

Chaque opération de messagerie prend du temps en fonction de nombreux facteurs (délais réseau, taille des données, performance du serveur, etc.). Vous pouvez définir un délai d’attente pour toutes les opérations de messagerie. L’exemple de code ci‑dessus montre comment faire cela en utilisant le Délai d’attente propriété. Remarque : vous ne devez pas définir de grandes valeurs afin d’éviter de longues attentes dans votre application.

Configurer le délai d’attente d’opération

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

    // some code...
}

Limiter le délai d’attente d’accueil

Le client IMAP peut utiliser le mode automatique pour établir une connexion. Dans ce mode, le client IMAP parcourt tous les paramètres de connexion possibles jusqu’à ce que la connexion soit établie. Un serveur IMAP, en cas de connexion correcte, envoie une chaîne d’accueil au client. Les serveurs peuvent utiliser une initiation de connexion SSL/TLS implicite ou explicite (START TLS). Si le mode de connexion ne correspond pas (par exemple, le serveur attend une connexion SSL implicite mais le client tente d’établir une connexion non sécurisée ou SSL explicite), le serveur n’enverra pas de chaîne d’accueil et l’utilisateur attendra longtemps jusqu’à ce que le délai d’attente atteigne la chaîne d’accueil, et le client passe à l’option de connexion suivante. Pour éviter ce problème, la propriété GreetingTimeout a été introduite. Cette propriété vous permet de définir le délai d’attente pour la chaîne d’accueil, et de réduire le temps d’établissement automatique de la connexion.

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

Utilisation des protocoles cryptographiques avec IMAP

Aspose.Email prend en charge les protocoles cryptographiques SSL (obsolète) et TLS pour assurer la sécurité des communications. Vous pouvez activer le chiffrement cryptographique afin de protéger les échanges de données entre votre application et les serveurs de messagerie.

NOTE: Vous ne devez définir que les versions du protocole prises en charge par le .NET Framework. Si certaines versions du protocole cryptographique ne sont pas supportées par votre version actuelle du .NET Framework, elles seront ignorées et sautées. Dans ce cas, aucune exception ne sera générée. Veuillez utiliser SetSupportedEncryptionUnsafe méthode si vous souhaitez définir les protocoles sans aucune vérification de compatibilité.

L’exemple de code ci‑dessous vous montre comment définir TLS 1.3 pour ImapClient instance de classe.

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

    // some code...
}

Dans le cas où un protocole de chiffrement spécifié n’est pas supporté dans la version actuelle du .NET Framework, la différence de comportement entre SetSupportedEncryptionUnsafe méthode et SupportedEncryption propriété est la suivante :

  • Si SupportedEncryption propriété est utilisée, le client de messagerie rétrograde le protocole de chiffrement à un niveau pris en charge.
  • Si SetSupportedEncryptionUnsafe méthode est utilisée, le client de messagerie lève des exceptions.

Utilisation de la commande IMAP IDLE

API d’Aspose.Email ImapClient fournit la capacité d’ouvrir une connexion au serveur et d’attendre l’arrivée d’un message e‑mail. Cela évite de sonder le serveur à plusieurs reprises pour chaque e‑mail entrant. Le fragment de code suivant montre comment utiliser la bibliothèque Aspose.Email pour surveiller une boîte de réception IMAP afin de détecter les nouveaux messages et les suppressions, puis d’exécuter des actions spécifiques selon ces événements :

// 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);

L’exemple de code suivant montre comment configurer une surveillance asynchrone des nouveaux messages e‑mail :

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
}

Prise en charge des extensions IMAP

L’API Aspose.Email prend en charge les extensions IMAP. Les extensions IMAP suivantes sont actuellement prises en charge par l’API. Ces extensions IMAP ne sont pas supportées par tous les serveurs.

// 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);
}

Commande de liste étendue IMAP4

L’extrait de code suivant vous montre comment utiliser la commande de liste étendue IMAP4.

// 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;
        }
    }
}
Gestion des messages sur le serveur IMAP