Feedback

C# - POP3 E-Mails abrufen

Veröffentlicht von am 05.04.2011
(1 Bewertungen)
Ein (vereinfachtes) Snippet, das zeigt, wie man POP-3 E-Mails abrufen kann.

Einfach ein MailProvider Objekt erzeugen, dabei die Zugangsdaten übergeben und mithilfe von MailProvider.GetMails() die Mail-Objekte erhalten.
GFU-Schulungen  [Anzeige]

C# Aufbaukurs

Sie haben grundlegende .NET- und C#-Kenntnisse und und wollen diese nun erweitern. Der Aufbaukurs C# führt Sie ein die Arbeit mit Interfaces und Delegates, Generics und Parallel Computing.

C# 2017/2015/2013 Aufbau

In dieser Schulung lernen Sie fortgeschrittene Techniken im Bereich .Net C#. Dabei stehen neben den eigentlichen Techniken auch architektonische Aspekte im Mittelpunkt.

// Mail.cs
namespace Tools
{
    /// <summary>
    /// Stellt eine E-Mail dar.
    /// </summary>
    public class Mail
    {
        #region Vars
        private string mSenderMail;
        private string mReceiverMail;
        private string mTitle;
        private string mContent;
        #endregion

        #region Properties
        /// <summary>
        /// E-Mail Adresse des Versenders
        /// </summary>
        public string SenderMail
        {
            get { return mSenderMail; }
            set { mSenderMail = value; }
        }
        /// <summary>
        /// E-Mail Adresse des Empfängers
        /// </summary>
        public string ReceiverMail
        {
            get { return mReceiverMail; }
            set { mReceiverMail = value; }
        }
        /// <summary>
        /// Betreff
        /// </summary>
        public string Title
        {
            get { return mTitle; }
            set { mTitle = value; }
        }
        /// <summary>
        /// Inhalt
        /// </summary>
        public string Content
        {
            get { return mContent; }
            set { mContent = value; }
        }
        #endregion
    }
}


// MailProvider.cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Sockets;
using System.Text;

namespace Tools
{
    /// <summary>
    /// Stellt einen MailProvider zur Verfügung,
    /// der E-Mails abrufen kann.
    /// </summary>
    public class MailProvider
    {
        #region Vars
        private NetworkStream mPop3Stream;
        private StreamReader mStreamListener;
        private byte[] mCommandBuffer = new byte[1024];
        ASCIIEncoding mAscEncoding = new ASCIIEncoding();
        private string mPopServer;
        private int mPort;
        private string mUser;
        private string mPassword;
        #endregion

        #region Properties
        /// <summary>
        /// POP-3 Server
        /// </summary>
        public string PopServer
        {
            get { return mPopServer; }
            set { mPopServer = value; }
        }
        /// <summary>
        /// Port des Servers
        /// </summary>
        public int Port
        {
            get { return mPort; }
            set { mPort = value; }
        }
        /// <summary>
        /// Benutzername
        /// </summary>
        public string User
        {
            get { return mUser; }
            set { mUser = value; }
        }
        /// <summary>
        /// Passwort
        /// </summary>
        public string Password
        {
            set { mPassword = value; }
        }
        #endregion

        #region Ctor
        /// <summary>
        /// Initialisiert einen neuen MailProvider,
        /// der E-Mail empfangen kann.
        /// </summary>
        public MailProvider(string popServer, int port, string user, string pw)
        {
            // Zugangsinformationen zuweisen
            mPopServer = popServer;
            mPort = port;
            mUser = user;
            mPassword = pw;

            // Verbindung zum Server herstellen
            establishConnection();
        }
        #endregion

        #region Private Methods
        /// <summary>
        /// Stellt die Verbindung zum POP-Server her.
        /// </summary>
        private void establishConnection()
        {
            TcpClient server = new TcpClient();

            // Verbindung herstellen
            server.Connect(this.PopServer, this.Port);

            // Streams einleiten
            mPop3Stream = server.GetStream();
            mStreamListener = new StreamReader(mPop3Stream);

            // Wenn erfolgreich verbunden
            if (server.Connected)
            {
                mStreamListener.ReadLine();

                // Am Server anmelden
                mCommandBuffer = mAscEncoding.GetBytes(String.Format("USER {0}\r\n", this.User));
                mPop3Stream.Write(mCommandBuffer, 0, mCommandBuffer.Length);
                mStreamListener.ReadLine();
                mCommandBuffer = mAscEncoding.GetBytes(String.Format("PASS {0}\r\n", mPassword));
                mPop3Stream.Write(mCommandBuffer, 0, mCommandBuffer.Length);
                mStreamListener.ReadLine();
            }
        }
        /// <summary>
        /// Parst anhand des übergebenen Strings ein Mail-Objekt.
        /// </summary>
        private Mail parseMail(string input)
        {
            Mail retVal = null;

            // E-Mail in 2 Hälften zerlegen (Header und Body)
            string[] emailSplit = input.Split(new string[] { "\r\n\r\n" }, StringSplitOptions.None);
            string header = String.Empty;
            string body = String.Empty;

            if (emailSplit.Length >= 2)
            {
                // Header
                header = emailSplit[0];
                // Body
                for (int i = 1; i < emailSplit.Length - 1; i++) body = String.Concat(body, "\r\n\r\n" ,emailSplit[i]);
            }

            // Header-Informationen filtern
            retVal = getHeaderInformations(header);

            // Content zuweisen
            retVal.Content = body;

            // Mail-Objekt zurückgeben
            return retVal;
        }
        /// <summary>
        /// Gibt die Headerinformationen zurück.
        /// </summary>
        private Mail getHeaderInformations(string header)
        {
            Mail retVal = new Mail();

            // Jede einzelne Zeile parsen
            foreach (string line in header.Split(new string[] { "\r\n" }, StringSplitOptions.None))
            {
                // Aufteilen in Schlüssel und Wert
                string[] lineSplit = line.Split(new string[] { ": " }, StringSplitOptions.None);
                string key = String.Empty;
                string value = String.Empty;

                if (lineSplit.Length >= 2)
                {
                    // Schlüssel
                    key = lineSplit[0];
                    // Wert
                    for (int i = 1; i < lineSplit.Length; i++) value = String.Concat(value, lineSplit[i]);
                }

                // Je nach Schlüssel den dazugehörigen Wert zuweisen
                switch (key)
                {
                    // Absender
                    case "From":
                        retVal.SenderMail = value;
                        break;
                    // Empfänger
                    case "To":
                        retVal.ReceiverMail = value;
                        break;
                    // Betreff
                    case "Subject":
                        retVal.Title = value;
                        break;
                }
            }

            return retVal;
        }
        #endregion

        #region Public Methods
        /// <summary>
        /// Gibt alle E-Mails zurück.
        /// </summary>
        public List<Mail> GetMails()
        {
            List<Mail> retVal = new List<Mail>();
            List<string> mailList = new List<string>();

            // Liste mit allen E-Mails anfordern
            mCommandBuffer = mAscEncoding.GetBytes("LIST\r\n");
            mPop3Stream.Write(mCommandBuffer, 0, mCommandBuffer.Length);
            mStreamListener.ReadLine();

            // Solange wie nicht "." ausgelesen wird, sind noch E-Mails
            // auf dem Server vorhanden
            string currMsg = mStreamListener.ReadLine();
            while (currMsg != ".")
            {
                mailList.Add(currMsg);
                currMsg = mStreamListener.ReadLine();
            }

            // Die E-Mail Liste durchgehen
            foreach (string listVal in mailList)
            {
                Mail mail = null;

                // Mail-Index filtern
                int mailNr = -1;
                try
                {
                    mailNr = Convert.ToInt32(listVal.Split(' ')[0]);
                }
                catch { }

                // Wenn der Mail-Index gefunden wurde, kompletten Mail Inhalt abrufen
                if (mailNr != -1)
                {
                    mCommandBuffer = mAscEncoding.GetBytes(String.Format("RETR {0}\r\n",
                        mailNr));
                    mPop3Stream.Write(mCommandBuffer, 0, mCommandBuffer.Length);
                    StringBuilder mailContent = new StringBuilder();

                    // Solange nicht "." augelesen wird, ist die Email noch nicht zuende
                    string tmpLine = mStreamListener.ReadLine();
                    while (tmpLine != ".")
                    {
                        mailContent.AppendLine(tmpLine);
                        tmpLine = mStreamListener.ReadLine();
                    }

                    // E-Mail parsen
                    mail = parseMail(mailContent.ToString());
                }

                if (mail != null)
                    retVal.Add(mail);
            }

            return retVal;
        }
        #endregion
    }
}
Abgelegt unter mail, email, pop, pop3.

13 Kommentare zum Snippet

Christopher Kk schrieb am 05.04.2011:
Warum schreibst du alles selber? Email-Kommunikation gibt es im .NET Framework bereits vorimplementiert.

Weitehrin hältst du dich in keinster Weiße an die .NET Code-Konventionen.
Wäre schön wenn du Snippets posten könntest die wirklich von Nutzen sind.
Curry schrieb am 05.04.2011:
Dann zeig mir bitte mal, wie ich mithilfe von .NET E-Mails ABRUFEN soll...
Und an welche Konventionen halte ich mich hier denn bitte nicht?
Christopher Kk schrieb am 05.04.2011:
Haha das du die Abrufst hab ich doch vollkommen überlesen. Sorry mein Fehler.

Aber zu den Code-Konventionen. Private Member werden in C# nicht mit führenden "m" geschrieben. Methoden werden mit großen Anfangsbuchstaben geschrieben(Das hast du einmal drinne, aber nur bei einer öffentlichen Methode, weiß nicht ob das Absicht ist).
Curry schrieb am 06.04.2011:
Naja, ich schreib sie eben mit einem führenden m.
Und ja, ich schreibe nur öffentliche Methoden groß.
Curry schrieb am 06.04.2011:
Und achja, man darf ein "m" vorne dranhängen:


Rule 3@104
Synopsis: Do not prefix member fields
Language: C#
Level: 9
Category: Naming
Description
Exception:
Member fields can prefixed with an "m" character
Christopher Kk schrieb am 08.04.2011:
Alles klar, danke für die Info ;)
Legion schrieb am 15.04.2011:
Also ich finde nicht, dass man sich bei Snippets über "Code Konventionen" auslassen sollte, da diese nur Richtlinie sind, wie vernünftiger Code aussehen kann. Ansonsten nettes Snippet.
InSiDeR schrieb am 24.02.2012:
Aufruf:

List<Mail> mailList = new List<Mail>();
mailList = MailProvider.GetMails();

Klappt bei mir leider nicht. Er gibt doch eine Liste aus, welche ich übergeben möchte. Möchte meine E-Mail in einer ListView anzeigen lassen.

Fehler: Für das nicht statische Feld, die Methode oder die Eigenschaft "Tools.MailProvider.GetMails()" ist ein Objektverweis erforderlich.
InSiDeR schrieb am 24.02.2012:
Omg ich doof... ich habs gelöst :D
Man sollte auch das Objekt nutzen und nich die Klasse ._.
NeuerUser schrieb am 14.07.2013:
Gutes Snippet, aber die Mails werden nach dem Abrufen nicht als gelesen markiert, oder es werden nicht nur die ungelesenen Mails heruntergeladen. Wie kann man dieses Problem lösen. Zudem enthält der MailContent noch die Header, etc. Den Betreff kann man doch auch ohne das ganze Drumherum auslesen, warum geht das mit dem Mailinhalt nicht?
Kemiren schrieb am 08.09.2013:
Das Snippet hat mir gut geholfen. Habs etwas erweitert und es erfüllt jetzt genau meine Wünsche:)
joel schrieb am 29.02.2016:
Hallo,
Als .NET Anfänger habe ich das Snippet gut verstanden.

Wie kann ich das Attachement extrahieren und als file speichern?
joel schrieb am 29.02.2016:
Wie muss ich vorgehen, wenn das E-Mail mehr als ein Anhang enthält?
 

Logge dich ein, um hier zu kommentieren!