en utilisant c # .net bibliothèques pour vérifier les messages IMAP à partir de serveurs gmail [fermé]

https://stackoverflow.com/questions/545724

23-08-2019
|

Question

Quelqu'un at-il des exemples de code dans ce fait l'utilisation du framework .Net qui se connecte à des serveurs Googlemail pour vérifier via SSL IMAP pour les nouveaux e-mails?

La solution

L'URL énumérés ici peut-être vous intéresser

http://www.codeplex.com/InterIMAP

qui était à l'extension

Autres conseils

En tant que l'auteur du projet ci-dessus, je peux dire que oui, il ne supporte SSL.

Je travaille actuellement sur une nouvelle version de la bibliothèque qui sera complètement asynchrone pour augmenter la vitesse avec laquelle il peut interagir avec les serveurs IMAP.

Ce code, bien qu'incomplète, peut être téléchargé, ainsi que la bibliothèque synchrone d'origine (qui prend également en charge SSL), à partir du site Plex de code lien ci-dessus.

Je vous recommande regarder MailKit car il est probablement la bibliothèque de courrier le plus robuste là et il est Open Source (MIT) .

L'une des choses impressionnantes sur MailKit est que toutes les API de réseau sont annulables (quelque chose que je ne l'ai pas vu disponible dans toute autre bibliothèque IMAP).

Il est également la seule bibliothèque que je connaisse qui prend en charge le filetage des messages.

using System;
using System.Net;
using System.Threading;

using MailKit.Net.Imap;
using MailKit.Search;
using MailKit;
using MimeKit;

namespace TestClient {
    class Program
    {
        public static void Main (string[] args)
        {
            using (var client = new ImapClient ()) {
                using (var cancel = new CancellationTokenSource ()) {
                    client.Connect ("imap.gmail.com", 993, true, cancel.Token);

                    // If you want to disable an authentication mechanism,
                    // you can do so by removing the mechanism like this:
                    client.AuthenticationMechanisms.Remove ("XOAUTH");

                    client.Authenticate ("joey", "password", cancel.Token);

                    // The Inbox folder is always available...
                    var inbox = client.Inbox;
                    inbox.Open (FolderAccess.ReadOnly, cancel.Token);

                    Console.WriteLine ("Total messages: {0}", inbox.Count);
                    Console.WriteLine ("Recent messages: {0}", inbox.Recent);

                    // download each message based on the message index
                    for (int i = 0; i < inbox.Count; i++) {
                        var message = inbox.GetMessage (i, cancel.Token);
                        Console.WriteLine ("Subject: {0}", message.Subject);
                    }

                    // let's try searching for some messages...
                    var query = SearchQuery.DeliveredAfter (DateTime.Parse ("2013-01-12"))
                        .And (SearchQuery.SubjectContains ("MailKit"))
                        .And (SearchQuery.Seen);

                    foreach (var uid in inbox.Search (query, cancel.Token)) {
                        var message = inbox.GetMessage (uid, cancel.Token);
                        Console.WriteLine ("[match] {0}: {1}", uid, message.Subject);
                    }

                    client.Disconnect (true, cancel.Token);
                }
            }
        }
    }
}

Cross posté de l'autre question similaire. Voir ce qui se passe quand ils si semblables?

J'ai été à la recherche d'une solution IMAP pour un certain temps maintenant, et après avoir essayé un certain nombre, je vais avec AE.Net.Mail .

Il n'y a pas de documentation, que je considère comme un inconvénient, mais j'ai pu fouetter cela en regardant le code source (yay pour l'open source!) Et en utilisant IntelliSense. Le code ci-dessous se connecte spécifiquement au serveur IMAP de Gmail:

// Connect to the IMAP server. The 'true' parameter specifies to use SSL
// which is important (for Gmail at least)
ImapClient ic = new ImapClient("imap.gmail.com", "name@gmail.com", "pass",
                ImapClient.AuthMethods.Login, 993, true);
// Select a mailbox. Case-insensitive
ic.SelectMailbox("INBOX");
Console.WriteLine(ic.GetMessageCount());
// Get the first *11* messages. 0 is the first message;
// and it also includes the 10th message, which is really the eleventh ;)
// MailMessage represents, well, a message in your mailbox
MailMessage[] mm = ic.GetMessages(0, 10);
foreach (MailMessage m in mm)
{
    Console.WriteLine(m.Subject);
}
// Probably wiser to use a using statement
ic.Dispose();

Je ne suis pas affilié à cette bibliothèque ou quoi que ce soit, mais je l'ai trouvé très rapide et stable.

Lumisoft.net a à la fois client IMAP et le code du serveur que vous pouvez utilisation.

Je l'ai utilisé pour télécharger email à partir de Gmail. Le modèle d'objet est pas le meilleur, mais il est réalisable, et semble être assez souple et stable.

Voici le résultat partiel de mon pic de l'utiliser. Il va chercher les 10 premiers en-têtes avec des enveloppes, et va chercher le message complet:

using (var client = new IMAP_Client())
{
    client.Connect(_hostname, _port, _useSsl);
    client.Authenticate(_username, _password);
    client.SelectFolder("INBOX");
     var sequence = new IMAP_SequenceSet();
    sequence.Parse("0:10");
    var fetchItems = client.FetchMessages(sequence, IMAP_FetchItem_Flags.Envelope | IMAP_FetchItlags.UID,
                                        false, true);
    foreach (var fetchItem in fetchItems)
    {
        Console.Out.WriteLine("message.UID = {0}", fetchItem.UID);
        Console.Out.WriteLine("message.Envelope.From = {0}", fetchItem.Envelope.From);
        Console.Out.WriteLine("message.Envelope.To = {0}", fetchItem.Envelope.To);
        Console.Out.WriteLine("message.Envelope.Subject = {0}", fetchItem.Envelope.Subject);
        Console.Out.WriteLine("message.Envelope.MessageID = {0}", fetchItem.Envelope.MessageID);
    }
    Console.Out.WriteLine("Fetching bodies");
    foreach (var fetchItem in client.FetchMessages(sequence, IMAP_FetchItem_Flags.All, false, true)
    {             
        var email = LumiSoft.Net.Mail.Mail_Message.ParseFromByte(fetchItem.MessageData);             
        Console.Out.WriteLine("email.BodyText = {0}", email.BodyText);

    }
}

Il n'y a pas de support framework .NET pour IMAP. Vous aurez besoin d'utiliser certains composants 3ème partie.

Mail.dll composant électronique , il est très abordable et facile à utiliser, il prend également en charge SSL :

using(Imap imap = new Imap())
{
    imap.ConnectSSL("imap.company.com");
    imap.Login("user", "password");

    imap.SelectInbox();
    List<long> uids = imap.Search(Flag.Unseen);
    foreach (long uid in uids)
    {
        string eml = imap.GetMessageByUID(uid);
        IMail message = new MailBuilder()
            .CreateFromEml(eml);

        Console.WriteLine(message.Subject);
        Console.WriteLine(message.Text);
    }
    imap.Close(true);
}

S'il vous plaît noter que ceci est un produit commercial que j'ai créé.

Vous pouvez le télécharger ici. https://www.limilabs.com/mail

MailSystem.NET contient tous vos besoins pour IMAP4. Il est libres et Open Source.

(je suis impliqué dans le projet)

la source à la version ssl de c'est ici: http://atmospherian.wordpress.com/downloads /

Une autre alternative: HigLabo

https://higlabo.codeplex.com/documentation

Bonne discussion: https://higlabo.codeplex.com/discussions/479250

//====Imap sample================================//
//You can set default value by Default property
ImapClient.Default.UserName = "your server name";
ImapClient cl = new ImapClient("your server name");
cl.UserName = "your name";
cl.Password = "pass";
cl.Ssl = false;
if (cl.Authenticate() == true)
{
    Int32 MailIndex = 1;
    //Get all folder
    List<ImapFolder> l = cl.GetAllFolders();
    ImapFolder rFolder = cl.SelectFolder("INBOX");
    MailMessage mg = cl.GetMessage(MailIndex);
}

//Delete selected mail from mailbox
ImapClient pop = new ImapClient("server name", 110, "user name", "pass");
pop.AuthenticateMode = Pop3AuthenticateMode.Pop;
Int64[] DeleteIndexList = new.....//It depend on your needs
cl.DeleteEMail(DeleteIndexList);

//Get unread message list from GMail
using (ImapClient cl = new ImapClient("imap.gmail.com")) 
{
    cl.Port = 993;
    cl.Ssl = true; 
    cl.UserName = "xxxxx";
    cl.Password = "yyyyy";
    var bl = cl.Authenticate();
    if (bl == true)
    {
        //Select folder
        ImapFolder folder = cl.SelectFolder("[Gmail]/All Mail");
        //Search Unread
        SearchResult list = cl.ExecuteSearch("UNSEEN UNDELETED");
        //Get all unread mail
        for (int i = 0; i < list.MailIndexList.Count; i++)
        {
            mg = cl.GetMessage(list.MailIndexList[i]);
        }
    }
    //Change mail read state as read
    cl.ExecuteStore(1, StoreItem.FlagsReplace, "UNSEEN")
}


//Create draft mail to mailbox
using (ImapClient cl = new ImapClient("imap.gmail.com")) 
{
    cl.Port = 993;
    cl.Ssl = true; 
    cl.UserName = "xxxxx";
    cl.Password = "yyyyy";
    var bl = cl.Authenticate();
    if (bl == true)
    {
        var smg = new SmtpMessage("from mail address", "to mail addres list"
            , "cc mail address list", "This is a test mail.", "Hi.It is my draft mail");
        cl.ExecuteAppend("GMail/Drafts", smg.GetDataText(), "\\Draft", DateTimeOffset.Now); 
    }
}

//Idle
using (var cl = new ImapClient("imap.gmail.com", 993, "user name", "pass"))
{
    cl.Ssl = true;
    cl.ReceiveTimeout = 10 * 60 * 1000;//10 minute
    if (cl.Authenticate() == true)
    {
        var l = cl.GetAllFolders();
        ImapFolder r = cl.SelectFolder("INBOX");
        //You must dispose ImapIdleCommand object
        using (var cm = cl.CreateImapIdleCommand()) Caution! Ensure dispose command object
        {
            //This handler is invoked when you receive a mesage from server
            cm.MessageReceived += (Object o, ImapIdleCommandMessageReceivedEventArgs e) =>
            {
                foreach (var mg in e.MessageList)
                {
                    String text = String.Format("Type is {0} Number is {1}", mg.MessageType, mg.Number);
                    Console.WriteLine(text);
                }
            };
            cl.ExecuteIdle(cm);
            while (true)
            {
                var line = Console.ReadLine();
                if (line == "done")
                {
                    cl.ExecuteDone(cm);
                    break;
                }
            }
        }
    }
}

LumiSoft.ee - fonctionne très bien, assez facile. Compile avec .NET 4.0.

Voici les liens nécessaires à leur lib et des exemples. Téléchargements principal:

http://www.lumisoft.ee/lsWWW/Download/Downloads/

Exemples de code:

sont situés ici: ... lsWWW / Téléchargement / Téléchargements / Exemples /

.NET:

se trouvent ici: ... lsWWW / Téléchargement / Téléchargements / Net /

Je suis en train d'un simple échantillon à l'aide de leur lib sur CodePlex (IMAPClientLumiSoft.codeplex.com). Vous devez obtenir leurs bibliothèques directement à partir de leur site. Je ne suis pas les inclure parce que je ne conserve pas leur code et je n'avoir des droits sur le code. Aller aux liens ci-dessus et le télécharger directement. Je définir les propriétés du projet Lumisoft dans mon VS2010 pour construire tous dans .NET 4.0 qui a été fait sans erreur. Leurs échantillons sont assez complexes et peut-être même trop serré de codage quand juste un exemple. Bien que je pense que ceux-ci sont destinées aux développeurs de niveau avancé en général.

Leur projet a travaillé avec quelques réglages mineurs. Les coups secs: Leur exemple IMAP client Winform est défini dans les propriétés du projet comme « Release » qui empêche VS de rupture sur les points de débogage. Vous devez utiliser pour définir le projet « actif (Debug) » pour les points d'arrêt pour travailler la solution « Configuration Manager ». Leurs exemples utilisent des méthodes anonymes pour les gestionnaires d'événements qui est grand codage serré ... pas vraiment bien comme outil d'enseignement. Mon projet utilise la méthode des événements « nommés » les gestionnaires afin que vous pouvez définir des points d'arrêt à l'intérieur des gestionnaires. Cependant leur est une excellente façon de gérer le code en ligne. Ils auraient pu utiliser les méthodes disponibles Lambda nouvelles depuis .NET 3.0, mais n'a pas et je ne pas essayer de les convertir.

A partir de leurs échantillons j'ai simplifié le client IMAP au strict minimum.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow