Como Estabelecer Conexões IMAP em C#

Listando Extensões do Servidor IMAP

da Aspose.Email ImapClient permite que você recupere as extensões do servidor que ele suporta, como IDLE, UNSELECT, QUOTA, etc. Isso ajuda a identificar a disponibilidade de uma extensão antes de usar o cliente para aquela funcionalidade específica. O GetCapabilities() método retorna os tipos de extensão suportados na forma de um array de strings. O trecho de código a seguir mostra como recuperar as extensões.

Conexão IMAP Padrão

O ImapClient classe permite que aplicações gerenciem caixas de correio IMAP usando o protocolo IMAP. O ImapClient classe é usada para conectar a servidores de e‑mail IMAP e gerenciar e‑mails nas pastas de e‑mail IMAP. Para conectar a um servidor IMAP

Crie uma instância do ImapClient classe.
Especifique o nome do host, nome de usuário e senha no Construtor ImapClient.

Observação: as restrições de senha devem atender aos requisitos do servidor. O cliente de e‑mail não adiciona restrições de senha.

Uma vez que ImapClient a instância é iniciada, a próxima chamada a qualquer operação usando essa instância conectará ao servidor. O trecho de código a seguir mostra como conectar a um servidor IMAP usando as etapas acima.

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

Conexão IMAP com SSL Ativado

Conectando ao Servidor IMAP descreveu como conectar a um servidor IMAP em quatro etapas simples:

Crie uma instância do ImapClient classe.
Especifique o nome do host, nome de usuário e senha.
Especifique a porta.
Especifique as Opções de Segurança.

O processo de conexão a um servidor IMAP com SSL habilitado é semelhante, mas requer que você configure mais algumas propriedades:

Definir SecurityOptions para SSLImplicit.

O trecho de código a seguir mostra como

Defina um nome de usuário, senha e porta.
Defina a opção de segurança.

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

Configuração de Conexão Proxy

Conectando ao Servidor via Proxy

Os servidores proxy são comumente usados para comunicar-se com o mundo externo. Nesses casos, os clientes de e‑mail não conseguem se comunicar pela Internet sem especificar o endereço do proxy. Aspose.Email oferece suporte às versões 4, 4a e 5 do protocolo proxy SOCKS. Este artigo fornece um exemplo funcional de acesso à caixa de correio usando um servidor proxy de e‑mail. Para acessar a caixa de correio via um servidor proxy:

Initialize SocksProxy com as informações necessárias, ou seja, endereço do proxy, porta e versão SOCKS.
Initialize ImapClient com endereço do host, nome de usuário, senha e quaisquer outras configurações.
Defina o SocksProxy propriedade do cliente para o SocksProxy objeto criado acima.

O trecho de código a seguir mostra como recuperar a caixa de correio via um servidor 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);
}

Conectando ao Servidor 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");
}

Conexão em Modo Somente Leitura

O ImapClient classe fornece um ReadOnly propriedade que, quando definida como true, indica que nenhuma alteração deve ser feita ao estado permanente da caixa de correio. O exemplo de código a seguir demonstra o uso de ImapClient.ReadOnly propriedade. Ela obtém a contagem de mensagens não lidas, então busca uma mensagem e novamente obtém a contagem de mensagens não lidas em modo somente leitura. A contagem das mensagens não lidas permanece a mesma, indicando que o estado permanente da caixa de correio não foi alterado.

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

Configuração de Autenticação CRAM-MD5

Para autenticação segura e acesso ao servidor de e‑mail, o Aspose.Email para .NET oferece o método de autenticação CRAM-MD5. O trecho de código a seguir mostrará como ele funciona com o ImapClient:

imapClient.AllowedAuthentication = ImapKnownAuthenticationType.CramMD5;

Definindo Tempos Limite para Operações IMAP

Cada operação de e‑mail leva algum tempo dependendo de diversos fatores (atrasos de rede, tamanho dos dados, desempenho do servidor, etc.). Você pode definir um tempo limite para todas as operações de e‑mail. O exemplo de código abaixo mostra como fazer isso usando o Tempo limite propriedade. Nota: não deve definir valores grandes para evitar longas esperas em sua aplicação.

Configurar Tempo Limite de Operação

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

    // some code...
}

Restringir Tempo Limite de Saudação

O cliente IMAP pode usar o modo automático para estabelecer uma conexão. Nesse modo, o cliente IMAP tenta todos os parâmetros de conexão possíveis até que a conexão seja estabelecida. Um servidor IMAP, ao receber a conexão correta, envia uma string de saudação ao cliente. Os servidores podem usar iniciação de conexão SSL/TLS implícita ou explícita (START TLS). Se o modo de conexão estiver incompatível (por exemplo, o servidor aguarda uma conexão SSL implícita, mas o cliente tenta estabelecer uma conexão não segura ou SSL explícita), o servidor não enviará a string de saudação e o usuário ficará aguardando até que o timeout de saudação ocorra, e o cliente passará para a próxima opção de conexão. Para evitar esse problema, foi introduzida a propriedade GreetingTimeout. Essa propriedade permite definir o tempo limite para a string de saudação, reduzindo o tempo de estabelecimento automático da conexão.

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

Usando Protocolos Criptográficos com IMAP

O Aspose.Email suporta os protocolos criptográficos SSL (obsoleto) e TLS para fornecer segurança nas comunicações. Você pode habilitar a criptografia para proteger a troca de dados entre sua aplicação e os servidores de email.

NOTA: Você deve definir apenas as versões do protocolo que são suportadas pelo .NET Framework. Se algumas versões do protocolo criptográfico não forem suportadas pela sua versão atual do .NET Framework, elas serão ignoradas e puladas. Nesse caso, exceções não serão geradas. Por favor, use SetSupportedEncryptionUnsafe método se você quiser definir os protocolos sem verificações de compatibilidade.

O exemplo de código abaixo mostra como definir TLS 1.3 para ImapClient instância de classe.

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

    // some code...
}

Caso um protocolo de criptografia especificado não seja suportado na versão atual do .NET Framework, a diferença de comportamento entre SetSupportedEncryptionUnsafe método e SupportedEncryption propriedade é a seguinte:

Se SupportedEncryption propriedade é usada, o cliente de email reverte o protocolo de criptografia para um nível suportado.
Se SetSupportedEncryptionUnsafe método é usado, o cliente de email lança exceções.

Usando o Comando IMAP IDLE

APIs do Aspose.Email ImapClient fornece a capacidade de abrir uma conexão ao servidor e aguardar a chegada de uma mensagem de e‑mail. Isso evita o polling constante do servidor por novas mensagens. O trecho de código a seguir demonstra como usar a biblioteca Aspose.Email para monitorar uma caixa de entrada IMAP em busca de novas mensagens e mensagens excluídas, realizando ações específicas com base nesses eventos:

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

O exemplo de código a seguir mostra como configurar o monitoramento assíncrono de novas mensagens de 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
}

Suporte a Extensões IMAP

A API Aspose.Email oferece suporte a extensões IMAP. As seguintes extensões IMAP são suportadas atualmente pela API. Essas extensões IMAP não são suportadas por todos os servidores.

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

Comando de Listagem Estendida IMAP4

O trecho de código a seguir mostra como usar o comando de listagem estendida do 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;
        }
    }
}

Gerenciando Mensagens no Servidor IMAP