IMAP IDLE模式(推送邮件)

在电子邮件技术中，IDLE是RFC 2177中描述的一项IMAP功能，它允许客户端向服务器表明它已准备好接受实时通知。

Internet消息访问协议IMAP4协议，它要求客户端轮询服务器来更改所选中的文件夹（如拉取新邮件、删除邮件），如果能让服务器推送通知客户端，告知客户端有新邮件的话会更方便客户端，尤其是在手机端的时候，大量的轮询查询服务器会耗费电量和流量，用户是不太允许这样做的，而且也不是很及时的收到邮件。

考虑到这种情况，其实IMAP4的扩展协议中是支持这个推送模式，即IMAP的IDLE模式。

首先我们用CAPABILITY 命令查询一下是否支持IDLE模式，因为并不是所有邮箱多支持的。

如qq邮箱：["CAPABILITY", "IMAP4", "IMAP4rev1", "IDLE", "XAPPLEPUSHSERVICE", "AUTH=LOGIN", "NAMESPACE", "CHILDREN", "ID", "UIDPLUS"]就支持这种模式，而163邮箱：["CAPABILITY", "IMAP4rev1", "XLIST", "SPECIAL-USE", "ID", "LITERAL+", "STARTTLS", "XAPPLEPUSHSERVICE", "UIDPLUS", "X-CM-EXT-1"]并不支持。

我们就用qq邮箱来测试一下，测试前请开通QQ邮箱的imap协议功能保持连接正常，关于IDLE命令的使用，需要先登录验证后，选中文件夹之后才可以使用，具体测试如下图：

查看命令可以知道，每次收到新邮件这会更改EXISTS的数量，这样就收到一个邮件通知，然后通过这个通知在去拉取邮件就可以。这是基本原理，具体到具体应用，由于我一直使用mailkit来获取邮件，而mailkit本身也是支持这种模式的。

mailkit具体代码如下：

 namespace TestMailKit
 {
     public partial class Form2 : Form
     {
         public Form2()
         {
             InitializeComponent();
         }

         private void button1_Click(object sender, EventArgs e)
         {
             TodoMail();
         }

         public static void TodoMail()
         {
             try
             {
                 using (var client = new ImapClient(new ProtocolLogger(Console.OpenStandardError())))
                 {
                     client.Connect("imap.qq.com", , true);
                     if (client.AuthenticationMechanisms.Contains("XOAUTH2"))
                         client.AuthenticationMechanisms.Remove("XOAUTH2");
                     client.Authenticate("110xxxxx31@qq.com", "******chfcf");

                     client.Inbox.Open(FolderAccess.ReadOnly);

                     // Get the summary information of all of the messages (suitable for displaying in a message list).
                     var messages = client.Inbox.Fetch(, -, MessageSummaryItems.Full | MessageSummaryItems.UniqueId).ToList();

                     // Keep track of messages being expunged so that when the CountChanged event fires, we can tell if it's
                     // because new messages have arrived vs messages being removed (or some combination of the two).
                     client.Inbox.MessageExpunged += (sender, e) =>
                     {
                         var folder = (ImapFolder)sender;

                         if (e.Index < messages.Count)
                         {
                             var message = messages[e.Index];

                             Console.WriteLine("{0}: expunged message {1}: Subject: {2}", folder, e.Index, message.Envelope.Subject);

                             // Note: If you are keeping a local cache of message information
                             // (e.g. MessageSummary data) for the folder, then you'll need
                             // to remove the message at e.Index.
                             messages.RemoveAt(e.Index);
                         }
                         else
                         {
                             Console.WriteLine("{0}: expunged message {1}: Unknown message.", folder, e.Index);
                         }
                     };

                     // Keep track of changes to the number of messages in the folder (this is how we'll tell if new messages have arrived).
                     client.Inbox.CountChanged += (sender, e) =>
                     {
                         // Note: the CountChanged event will fire when new messages arrive in the folder and/or when messages are expunged.
                         var folder = (ImapFolder)sender;

                         Console.WriteLine("The number of messages in {0} has changed.", folder);

                         // Note: because we are keeping track of the MessageExpunged event and updating our
                         // 'messages' list, we know that if we get a CountChanged event and folder.Count is
                         // larger than messages.Count, then it means that new messages have arrived.
                         if (folder.Count > messages.Count)
                         {
                             Console.WriteLine("{0} new messages have arrived.", folder.Count - messages.Count);

                             // Note: your first instict may be to fetch these new messages now, but you cannot do
                             // that in an event handler (the ImapFolder is not re-entrant).
                             //
                             // If this code had access to the 'done' CancellationTokenSource (see below), it could
                             // cancel that to cause the IDLE loop to end.
                         }
                     };

                     // Keep track of flag changes.
                     client.Inbox.MessageFlagsChanged += (sender, e) =>
                     {
                         var folder = (ImapFolder)sender;

                         Console.WriteLine("{0}: flags for message {1} have changed to: {2}.", folder, e.Index, e.Flags);
                     };

                     Console.WriteLine("Hit any key to end the IDLE loop.");
                     using (var done = new CancellationTokenSource())
                     {
                         // Note: when the 'done' CancellationTokenSource is cancelled, it ends to IDLE loop.
                         var thread = new Thread(IdleLoop);

                         thread.Start(new IdleState(client, done.Token));

                         Console.ReadKey();
                         done.Cancel();
                         thread.Join();
                     }

                     if (client.Inbox.Count > messages.Count)
                     {
                         Console.WriteLine("The new messages that arrived during IDLE are:");
                         foreach (var message in client.Inbox.Fetch(messages.Count, -, MessageSummaryItems.Full | MessageSummaryItems.UniqueId))
                             Console.WriteLine("Subject: {0}", message.Envelope.Subject);
                     }

                     client.Disconnect(true);
                 }
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.Message);
             }
         }

         static void IdleLoop(object state)
         {
             var idle = (IdleState)state;

             lock (idle.Client.SyncRoot)
             {
                 // Note: since the IMAP server will drop the connection after 30 minutes, we must loop sending IDLE commands that
                 // last ~29 minutes or until the user has requested that they do not want to IDLE anymore.
                 //
                 // For GMail, we use a 9 minute interval because they do not seem to keep the connection alive for more than ~10 minutes.
                 while (!idle.IsCancellationRequested)
                 {
                     // Note: Starting with .NET 4.5, you can make this simpler by using the CancellationTokenSource .ctor that
                     // takes a TimeSpan argument, thus eliminating the need to create a timer.
                     using (var timeout = new CancellationTokenSource())
                     {
                         using (var timer = new System.Timers.Timer( *  * ))
                         {
                             // End the IDLE command when the timer expires.
                             timer.Elapsed += (sender, e) => timeout.Cancel();
                             timer.AutoReset = false;
                             timer.Enabled = true;

                             try
                             {
                                 // We set the timeout source so that if the idle.DoneToken is cancelled, it can cancel the timeout
                                 idle.SetTimeoutSource(timeout);

                                 if (idle.Client.Capabilities.HasFlag(ImapCapabilities.Idle))
                                 {
                                     // The Idle() method will not return until the timeout has elapsed or idle.CancellationToken is cancelled
                                     idle.Client.Idle(timeout.Token, idle.CancellationToken);
                                 }
                                 else
                                 {
                                     // The IMAP server does not support IDLE, so send a NOOP command instead
                                     idle.Client.NoOp(idle.CancellationToken);

                                     // Wait for the timeout to elapse or the cancellation token to be cancelled
                                     WaitHandle.WaitAny(new[] { timeout.Token.WaitHandle, idle.CancellationToken.WaitHandle });
                                 }
                             }
                             catch (OperationCanceledException)
                             {
                                 // This means that idle.CancellationToken was cancelled, not the DoneToken nor the timeout.
                                 break;
                             }
                             catch (ImapProtocolException)
                             {
                                 // The IMAP server sent garbage in a response and the ImapClient was unable to deal with it.
                                 // This should never happen in practice, but it's probably still a good idea to handle it.
                                 //
                                 // Note: an ImapProtocolException almost always results in the ImapClient getting disconnected.
                                 break;
                             }
                             catch (ImapCommandException)
                             {
                                 // The IMAP server responded with "NO" or "BAD" to either the IDLE command or the NOOP command.
                                 // This should never happen... but again, we're catching it for the sake of completeness.
                                 break;
                             }
                             finally
                             {
                                 // We're about to Dispose() the timeout source, so set it to null.
                                 idle.SetTimeoutSource(null);
                             }
                         }
                     }
                 }
             }
         }

     }

     class IdleState
     {
         readonly object mutex = new object();
         CancellationTokenSource timeout;

         /// <summary>
         /// Get the cancellation token.
         /// </summary>
         /// <remarks>
         /// <para>The cancellation token is the brute-force approach to cancelling the IDLE and/or NOOP command.</para>
         /// <para>Using the cancellation token will typically drop the connection to the server and so should
         /// not be used unless the client is in the process of shutting down or otherwise needs to
         /// immediately abort communication with the server.</para>
         /// </remarks>
         /// <value>The cancellation token.</value>
         public CancellationToken CancellationToken { get; private set; }

         /// <summary>
         /// Get the done token.
         /// </summary>
         /// <remarks>
         /// <para>The done token tells the <see cref="Program.IdleLoop"/> that the user has requested to end the loop.</para>
         /// <para>When the done token is cancelled, the <see cref="Program.IdleLoop"/> will gracefully come to an end by
         /// cancelling the timeout and then breaking out of the loop.</para>
         /// </remarks>
         /// <value>The done token.</value>
         public CancellationToken DoneToken { get; private set; }

         /// <summary>
         /// Get the IMAP client.
         /// </summary>
         /// <value>The IMAP client.</value>
         public ImapClient Client { get; private set; }

         /// <summary>
         /// Check whether or not either of the CancellationToken's have been cancelled.
         /// </summary>
         /// <value><c>true</c> if cancellation was requested; otherwise, <c>false</c>.</value>
         public bool IsCancellationRequested
         {
             get
             {
                 return CancellationToken.IsCancellationRequested || DoneToken.IsCancellationRequested;
             }
         }

         /// <summary>
         /// Initializes a new instance of the <see cref="IdleState"/> class.
         /// </summary>
         /// <param name="client">The IMAP client.</param>
         /// <param name="doneToken">The user-controlled 'done' token.</param>
         /// <param name="cancellationToken">The brute-force cancellation token.</param>
         public IdleState(ImapClient client, CancellationToken doneToken, CancellationToken cancellationToken = default(CancellationToken))
         {
             CancellationToken = cancellationToken;
             DoneToken = doneToken;
             Client = client;

             // When the user hits a key, end the current timeout as well
             doneToken.Register(CancelTimeout);
         }

         /// <summary>
         /// Cancel the timeout token source, forcing ImapClient.Idle() to gracefully exit.
         /// </summary>
         void CancelTimeout()
         {
             lock (mutex)
             {
                 if (timeout != null)
                     timeout.Cancel();
             }
         }

         /// <summary>
         /// Set the timeout source.
         /// </summary>
         /// <param name="source">The timeout source.</param>
         public void SetTimeoutSource(CancellationTokenSource source)
         {
             lock (mutex)
             {
                 timeout = source;

                 if (timeout != null && IsCancellationRequested)
                     timeout.Cancel();
             }
         }
     }

 }

mailkit IDLE模式

通过上面的代码即可订阅邮件通知，方便的获取邮件。