Shulou(Shulou.com)06/02 Report--

Many novices are not very clear about how to implement a simple mail transceiver in C#. In order to help you solve this problem, the following editor will explain it in detail. People with this need can come and learn. I hope you can get something.

Introduction: in our daily work, the sending and receiving of e-mail should be a function that we often use. Therefore, it is also necessary to know the principles of e-mail applications. In this topic, we will introduce the principles of e-mail applications, the protocols involved in e-mail applications, and the implementation of a simple email transceiver program.

1. Basic knowledge of mail application

1.1 E-mail principles and related protocols

When it comes to the principle of e-mail, it is actually the same principle as sending mail and parcels in our real life. Let's review the process of sending mail in real life-first, let's write the letter, write the address of the recipient and the address of the writer on the envelope, and then put the letter in the mailbox. Then the people in the post office will pick up the letter in this mailbox at some point, and then the people in the post office will forward it to the local post office according to the address written on the envelope. The local post office then sends the letter to the recipient's mailbox (if you send a parcel, you may contact by phone, just like the things we bought on Taobao and JD.com, and the consignee contacted by phone). Finally, the recipient will collect the letter in his own mailbox. The above is roughly a process of sending letters in our daily life. We have already mentioned that the principle of e-mail is similar to this. Here we introduce the principle of e-mail in this topic, which can be compared with the process of sending letters in real life, so that it is easier to understand and grasp:

We use email applications (such as client-based Outlook email software and some Web-based email systems-Sina mailbox, Google mailbox, QQ Mail, etc.) to write a written email (equivalent to a real-life letter, of course, the recipient's address, email content, etc.) through the e-mail protocol (SMTP As described in the following email-related protocols), it is sent to the SMTP server (the place where the mail is stored, which is equivalent to the post office in life), and then the SMTP server forwards it to the corresponding SMTP receiving server through the SMTP protocol according to the recipient's address. (the SMTP server forwards the letter to the person equivalent to the real-life post office and delivers it to the recipient's local post office. However, in real life, post offices are all the same, so they can identify each other-- it means to send it to the local post office, which will receive it and help you send it to the mailbox of the designated person. on the Internet, it is stipulated through the SMTP protocol that other people's servers on other people's SMTP servers must recognize and receive the sent mail. The receiving mail server (POP3 server) stores the mail in the recipient's e-mail box (equivalent to the person in the local post office puts the letter in the recipient's mailbox), and finally the recipient can log in to his own e-mail box and connect with the POP3 server to download the sent mail from the POP3 server. In this way, the e-mail sent can be seen in the recipient's e-mail box (this is a process in which the recipient takes letters from his or her own mailbox in real life).

Note: there is a personal understanding in parentheses. If there is anything wrong, I hope you can point it out so that I can correct it in time.

The above has compared the principle of e-mail with the process of sending letters in real life. I believe we can have a better understanding of the principle of e-mail and the process of sending and receiving e-mail. In fact, many applications on the network can be understood by real-life examples. In this way, I think we can deepen our understanding of knowledge. Here is the content of the relevant protocols in the email:

The core of the application on the network is the protocol, because the protocol allows clients on the network to know each other about the data that has happened, so e-mail applications are no exception. There are also relevant e-mail protocols to complete the process of sending and receiving e-mail. These protocols are: SMTP (simple Mail transfer Protocol, Simple Mail Transfer Protocol), POP3 (Post Office Protocol, Post Office Protocol) and IMAP (Network Mail access Protocol). Internet Message Access Protocol).

SMTP--SMTP is mainly responsible for forwarding messages from one machine to another (you can understand the role of SMTP by comparing the email process above)

POP3--3 represents the version of the POP protocol and is mainly responsible for transferring messages from the mailbox (POP3 server) to the local computer.

The commonly used version of IMAP-- is the fourth version, namely IMAP4, which is mainly responsible for mail retrieval and processing functions. the client does not need to download mail to the local computer and can operate the mail and file directory on the server directly from the mail client software. it is an alternative protocol for POP3.

1.2 Classification of mail systems

Mail systems are mainly divided into two types-client-based mail systems and Web browser-based mail systems. Office OutLook is a client-side mail system, while mailboxes like QQ Mail, Sina and NetEase that we often use are all Web browser-based mail systems. The sending and receiving process of the client-side mail system is described by the following pictures (the pictures are removed from the Internet):

Figure 1.1 client-based email sending and receiving process

Through the mail client, the sender sends the edited mail to the mail service (SMTP server, which is also called the sender mail server in the sending process). The sender mail server identifies the receiving mail server (POP3 server) according to the address of the recipient, and then sends mail information to the POP3 server. The receiving mail server stores the mail in the recipient's email box and informs the receiver that there is a new mail. After the recipient connects to the POP3 server through the mail client, they can view the new message.

However, there are some differences between a Web browser-based mail system and a client-based mail system:

Based on Web browser mail system user agent (the concept of agent is that the user does not communicate with the server directly, but through the agent, let the agent communicate with the server, and then the user gets the information of the server from the agent, the agent is the role of the middleman, which is equivalent to the intermediary in life. Net many technologies use the agent. For example, the concept of delegation is actually a concept of an agent) is a Web browser, a client-based mail system but a mail client application, usually a Windows Form program.

The way that the browser sends mail to the SMTP server and gets the mail from the POP3 server is realized through the HTTP protocol, which is different from the client-based mail system (the client-based mail system is sent through the SMTP protocol or ESMTP (Extended SMTP) and obtained through the POP3 or IMAP protocol).

1.3 current major email service systems

E-mail service system-- is a service system that provides mailbox services to everyone. Of course, such a system is developed by special companies. We usually call such companies mail service providers. NetEase mailboxes, new mailboxes, Gmail mailboxes and so on that we usually use are all built on email service systems (my understanding here is-- the Sina we use. Mailboxes such as NetEase are equivalent to everyone's mailboxes in real life, and letters from the post office can be obtained through the mailbox. Similarly, mail from the mail service system can be obtained through the mailbox, so the e-mail system is equivalent to the post office. At present, the main e-mail service systems are as follows:

Postfix/Qmail-based mail system. For example, Yahoo mailbox is based on the Qmail system

Microsoft Exchange email system

IBM Lotus Domino mail system

Scalix mail system

Zimbra mail system

MDeamon mail system

2. support for mail sending on the Net platform

In the .NET class library, classes for handling mail are defined under the System.Net.Mail namespace, which makes it easier to send messages (these classes are encapsulation of the SMTP protocol, which makes us better at regional programming. We only need to use the methods and properties in the class to complete the sending of mail, and avoid writing complex SMTP protocol commands). Here is a screenshot of the class that supports sending mail under the System.Net.Mail namespace:

You can also see the role of each class from the name of the class in the picture, I will not introduce it here, you can refer to MSDN to see the use of each class, and I will have detailed notes to introduce the use of classes in the later implementation part of the program. From the figure, we can also see that there is only the word SMTP, but there is no word like POP3, which shows that the .net class library itself does not provide a wrapper class for the POP3 protocol, but we can use the Jmail component to complete the function of receiving mail from the POP3 server, the specific use of which will be introduced in the mail receiving section of the mail transceiver program.

Third, the realization of mail transceiver program.

3.1 realization of email sending function

3.1.1 SMTP protocol

SMTP protocol is a protocol for the transmission of e-mail. E-mail is sent through the SMTP server. The default port of the SMTP server is 25. There are usually two ways to send e-mail-one is without client authentication, that is, the client can send email anonymously (this method is called SMTP). The other is that the client must provide username and password authentication (this method is called ESMTP,Extended SMTP). At present, most mail servers use username and password authentication.

The process of sending mail from the client is to send the mail to the SMTP server through the client software (the mail transceiver in this program), and then to the target SMTP server by the SMTP server. The contents of the SMTP protocol are described below:

The SMTP protocol defines a total of 14 commands, which are composed of command codes and climate parameter fields, regardless of case (the commands of each protocol are similar through the description of the previous topic). Here are five commonly used command codes.

E-mail consists of four parts: the envelope, the header, the body and the closing symbol. Here are the details of these four parts:

1. Envelope

The envelope includes the sender's email address and the recipient's email address, which corresponds to two SMTP commands-Mail from: mytest1989@sina.cn (sender's address) and Rcpt to: 794170314@qq.com

two。 First part

The commands commonly used in the first part are:

Subject:-- indicates the subject of the message

Date:-- indicates the time when the email was sent

Reply-to:-- indicates the reply address of the email

Content-Type:-- represents the type of message that contains text, HTML hypertext, and attachments.

XmurPriorityVue-indicates the priority of sending mail, and a priority of 3 means regular mail; for example, X-Priority:3

3. Text

The text, of course, refers to the content of the message. It is specified by the Data command. The first part ends with a blank line. Here is the body.

4. End symbol

Email with "." End,

After receiving the SMTP command, the receiver will give a response code. Each command has only one response code. The SMTP response code is also composed of three digits, followed by some text information. The format of the response information is as follows:

Response code text message

After the client sends out a command, the server returns a response. The sender must wait for the response from the server before sending the next command, and then continue to send the command after successfully receiving the response code.

Attached: response codes commonly used in SMTP:

3.1.2 the process of sending messages

The first step: the client establishes a connection with the server (in this step, the client first sends the EHLO local connection command. If the server returns the "220s" response code, it indicates that the server is ready, and then the client continues to send the "Auto login" command to request login. After receiving the command, the server returns the "334" response code, indicating that the user name is to be entered, and then the client sends the user name command, and then sends the password command after the response. There will also be comments in the implementation of the program. )

Step 2: the envelope that the client sends the message

Step 3: start sending email data (including the header, body and closing symbol, note: the closing symbol should be on a separate line, indicating the end of sending the message)

Step 4: disconnect the client from the server.

3.1.3 implementation code for sending function

I believe that after the above theory explains the process of sending mail, it is not difficult to realize the function of sending mail, and the SMTPClient class in the .net class library encapsulates the SMTP protocol for us, so that we do not have to remember those specific commands when we implement the function of sending mail. We only need to use the methods provided in this class to complete the sending of mail (of course, you can also do it by sending commands. The method of the SMTPClient class is also used to help us complete the function of sending commands. The following is the core code of the mail sending function:

View Code # region email sending function Code / / add attachment private void btnAddFile_Click (object sender, EventArgs e) {OpenFileDialog openFileDialog = new OpenFileDialog (); openFileDialog.CheckFileExists = true; / / only accept valid file name openFileDialog.ValidateNames = true / / allow multiple files to be selected at a time as attachments openFileDialog.Multiselect = true; openFileDialog.Filter = "all files (*. *) | *. *"; if (openFileDialog.ShowDialog ()! = DialogResult.OK) {return } if (openFileDialog.FileNames.Length > 0) {/ / because multiple files are allowed to be selected, AddRange is used instead of the Add method cmbAttachment.Items.AddRange (openFileDialog.FileNames) }} / / remove attachments private void btnDeleteFile_Click (object sender, EventArgs e) {int index = cmbAttachment.SelectedIndex; if (index = =-1) {MessageBox.Show ("Please select attachments to delete!" , "prompt", MessageBoxButtons.OK, MessageBoxIcon.Information); return;} else {cmbAttachment.Items.RemoveAt (index) }} / / send email private void btnSend_Click (object sender, EventArgs e) {this.Cursor = Cursors.WaitCursor / / instantiating a sent mail / / is equivalent to writing a letter first in real life. In the program, the letter (mail) is abstracted as a mail class MailMessage mailMessage = new MailMessage () / / indicate the address, subject, content and other information of the email to be sent / / the sender's address is the address of the login transceiver, which is equivalent to our usual Web version mailbox or the mailbox configured in OutLook mailMessage.From = new MailAddress (tbxUserMail.Text); mailMessage.To.Add (txbSendTo.Text) MailMessage.Subject = txbSubject.Text; mailMessage.SubjectEncoding = Encoding.Default; mailMessage.Body = richtbxBody.Text; mailMessage.BodyEncoding = Encoding.Default; / / sets the content of the message body that is not in Html format mailMessage.IsBodyHtml = false / / set the priority of the message to normal priority mailMessage.Priority = MailPriority.Normal; / / mailMessage.ReplyTo = new MailAddress (tbxUserMail.Text); / / Encapsulation sent attachment System.Net.Mail.Attachment attachment = null If (cmbAttachment.Items.Count > 0) {for (int I = 0; I)

< cmbAttachment.Items.Count; i++) { string fileNamePath = cmbAttachment.Items[i].ToString(); string extName = Path.GetExtension(fileNamePath).ToLower(); if (extName == ".rar" || extName == ".zip") { attachment = new System.Net.Mail.Attachment(fileNamePath, MediaTypeNames.Application.Zip); } else { attachment = new System.Net.Mail.Attachment(fileNamePath,MediaTypeNames.Application.Octet); } // 表示MIMEContent-Disposition标头信息 // 对于ContentDisposition具体类的解释大家可以参考MSDN // 这里我就不重复贴出来了，给个地址: http://msdn.microsoft.com/zh-cn/library/System.Net.Mime.ContentDisposition.aspx (着重看备注部分) ContentDisposition cd = attachment.ContentDisposition; cd.CreationDate = File.GetCreationTime(fileNamePath); cd.ModificationDate = File.GetLastWriteTime(fileNamePath); cd.ReadDate = File.GetLastAccessTime(fileNamePath); // 把附件对象加入到邮件附件集合中 mailMessage.Attachments.Add(attachment); } } // 发送写好的邮件 try { // SmtpClient类用于将邮件发送到SMTP服务器 // 该类封装了SMTP协议的实现， // 通过该类可以简化发送邮件的过程，只需要调用该类的Send方法就可以发送邮件到SMTP服务器了。 smtpClient.Send(mailMessage); MessageBox.Show("邮件发送成功！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information); } catch(SmtpException smtpError) { MessageBox.Show("邮件发送失败：[" + smtpError.StatusCode + "]；[" + smtpError.Message+"];\r\n["+smtpError.StackTrace+"]." ,"错误",MessageBoxButtons.RetryCancel,MessageBoxIcon.Error); } finally { mailMessage.Dispose(); this.Cursor = Cursors.Default; } } #endregion 3.2 邮件接收功能的实现 3.2.1 POP3协议 前面介绍了邮件的发送，当然接收者需要登录邮箱来查看收到的邮件了，此时就必有有一个协议去读取服务器上邮件，POP3就是这样的一个协议。还有两外一种协议也是用来接收邮件的——IMAP协议，它与POP3协议区别有： 1. IMAP使用的端口号是143而POP3邮件服务器通过监听110端口来提供POP3服务； 2 . IMAP 允许客户端在邮件服务器上建立文件夹来保持邮件，而不用把邮件下载到本地。而POP3需要把邮件下载到本地。 和SMTP协议一样，客户端要通过POP3协议从POP3服务器上获取邮件，也需要先与POP3服务器建立TCP连接，等待服务器向客户端发送确认信息表明连接成功时，客户端才可以继续发送命令给服务器来获取邮件，在POP3协议中，规定的命令也是几十条的，每条命令由命令和参数两部分组成，都是以回车换行结束，并且命令和参数之间由空格分隔，命令通常也是由3-4个字母组成，参数最多可以为40个字符的长度，而服务器的响应信息是由一个状态码和可能附加信息的字符组成，所有的响应信息也是以回车换行结束的。状态码和其他协议定义的状态码有点不一样，POP3服务器响应的状态码有两种——"+OK"(确定)和"-ERR"（失败）。这样客户端可以通过检查响应的状态码所包含的字符来判断服务器是否响应客户端发送的命令，即响应信息中包含"+OK"表示成功响应，包含"-ERR"表示服务器未响应。同时在程序的实现中大家可以通过Debug来查看响应消息的组成，这样可以加深理解。 3.2.2 邮件接收的过程 客户端从服务器接收邮件的过程主要经历3个状态：授权状态、操作状态和更新状态 （1）授权状态——客户端发送与POP3服务器的TCP连接请求，服务器接收后发送一个响应确认信息之后，此时客户端需要发送正确的用户名和密码进行确认，因为在邮件服务器上有很多用户邮箱，只有提供正确的用户名和密码才有权限访问自己的邮箱，就像现实生活中我们邮箱的钥匙一样的。 发送用户名命令： USER mytest1989@sina.cn 发送密码命令： PASS ******（这两个命令都在代码中有给出的，大家可以参考代码来理解邮件的接收过程） （2） 操作状态——如果客户端提供了正确的用户名和密码，则授权状态也就通过了，就相当于打开了在服务器上自己的邮箱，现在用户就有权限进去下载，查看和删除邮件等操作的，然后在现实生活中的取邮件和删除邮件都很简单（只要打开了邮箱门，用手去拿就可以了），然后在网络应用上，这些操作都需要发送POP3命令给服务器，服务器接收到命令后再给出响应。操作中常用的命令有： STAT 命令——该命令从服务器中获取邮件总数和总字节数，服务器响应命令返回邮件总数和总字节数。如： 客户端发送POP3命令： STAT 服务器响应命令： +OK 2 1340 服务器响应命令： LIST 命令——该命令从服务器中获得邮件列表和大小，服务器响应命令返回列出邮件列表和大小。如： 客户端发送POP3命令：LIST 服务器响应命令： +OK 2 message(1430 octect) 服务器响应命令：1 700 服务器响应命令：2 730 服务器响应命令： RETR 命令—— 该命令从服务器中获得一个邮件，格式为 RETR 如： 客户端发送POP3命令：RETR 1 服务器响应命令： 700 octets 服务器响应命令： 服务器响应命令： DELETE 命令——该命令告诉服务器将邮件标记为删除。（此时只是逻辑删除） （3）更新状态——客户端发送QUIT命令后，此时就进入更新状态，POP3服务器释放在操作状态中取得的资源，并将逻辑删除的邮件进行物理删除，然后关闭与客户端的TCP连接。这样整个邮件处理的过程就结束了。 3.2.3 接收功能的实现代码 有了前面接收邮件过程的介绍，再参考代码的实现，相信大家可以更好的理解客户端从POP3服务器中获取邮件的过程的，由于.net类库并没有帮我们封装POP3协议的实现类，要实现邮件的获取可以采用发送命令的方式，也可以使用Jmail组件，这个组件其实就是POP3协议的封装类，既然微软没有帮我们做，其他公司帮我们做好后来帮助我们简单的实现邮件的接收的一个类库罢了。然后在使用这个组件的过程中出现了好几个问题的，在源码中我都解释，大家可以下载源代码后查看的。 实现邮件接收的核心代码如下： // 登录邮箱（这里是本程序——邮件收发器） private void btnLogin_Click_1(object sender, EventArgs e) { // 与POP3服务器建立TCP连接 // 建立连接后把服务器上的邮件下载到本地 // 设置当前界面的光标为等待光标（就是我们看到的一个动的圆形） Cursor.Current = Cursors.WaitCursor; lsttbxStatus.Items.Clear(); try { // POP3服务器通过监听TCP110端口来提供POP3服务的 // 向POP3服务器发出tcp请求 tcpClient = new TcpClient(tbxPOP3Server.Text, 110); lsttbxStatus.Items.Add("正在连接..."); } catch { MessageBox.Show("连接失败", "错误", MessageBoxButtons.RetryCancel, MessageBoxIcon.Error); lsttbxStatus.Items.Add("连接失败！"); return; } // 连接成功的情况 networkStream = tcpClient.GetStream(); streamReader = new StreamReader(networkStream, Encoding.Default); streamWriter = new StreamWriter(networkStream, Encoding.Default); streamWriter.AutoFlush = true; string str; // 读取服务器返回的响应连接信息 str = GetResponse(); if (CheckResponse(str) == false) { lsttbxStatus.Items.Add("服务器拒接了连接请求"); return; } // 如果服务器接收请求 // 向服务器发送凭证——用户名和密码 // 向服务器发送用户名，请求确认 lsttbxStatus.Items.Add("核实用户名阶段..."); SendToServer("USER " + tbxUserMail.Text); str = GetResponse(); if (CheckResponse(str) == false) { lsttbxStatus.Items.Add("用户名错误."); return; } // 用户名审核通过后再发送密码等待确认 // 向服务器发送密码，请求确认 SendToServer("PASS "+txbPassword.Text); str = GetResponse(); if (CheckResponse(str) == false) { lsttbxStatus.Items.Add("密码错误！"); return; } lsttbxStatus.Items.Add("身份验证成功，可以开始会话"); // 向服务器发送LIST 命令，请求获得邮件列表和大小 lsttbxStatus.Items.Add("获取邮件...."); SendToServer("LIST"); str = GetResponse(); if (CheckResponse(str) == false) { lsttbxStatus.Items.Add("获取邮件列表失败"); return; } lsttbxStatus.Items.Add("邮件获取成功"); // 窗口控件控制 tabControlMyMailbox.Enabled = true; btnReadMail.Enabled = false; btnDownLoad.Enabled = false; btnDeleteMail.Enabled = false; // 登陆成功后实例化邮件发送对象，以便后面完成发送邮件的操作 // 实例化邮件发送类（SmtpClient）对象 if (smtpClient == null) { smtpClient = new SmtpClient(); smtpClient.Host = tbxSmtpServer.Text; smtpClient.Port = 25; // 不使用默认凭证，即需要认证登陆 smtpClient.UseDefaultCredentials = false; smtpClient.Credentials = new NetworkCredential(tbxUserMail.Text, txbPassword.Text); smtpClient.DeliveryMethod = SmtpDeliveryMethod.Network; } // 登陆成功后，自动接收新邮件 // 开始接收邮件 try { btnRefreshMailList.PerformClick(); } catch { MessageBox.Show("读取邮件列表失败！", "错误", MessageBoxButtons.RetryCancel, MessageBoxIcon.Error); } lsttbxStatus.Items.Add("登陆成功!"); lsttbxStatus.TopIndex = lsttbxStatus.Items.Count - 1; Cursor.Current = Cursors.Default; // 窗口控件控制 richtbxMailContentReview.Enabled = true; tbxUserMail.Enabled = false; txbPassword.Enabled = false; btnLogin.Enabled = false; btnLogout.Enabled = true; tbxSmtpServer.Enabled = false; tbxPOP3Server.Enabled = false; btnReadMail.Enabled = true; btnDownLoad.Enabled = true; btnDeleteMail.Enabled = true; tabControlMyMailbox.Focus(); } #region 处理与POP3服务器交互事件 // 获取服务器响应的信息 private string GetResponse() { string str = null; try { str = streamReader.ReadLine(); if (str == null) { lsttbxStatus.Items.Add("连接失败——服务器没有响应"); } else { lsttbxStatus.Items.Add("收到：[" + str + "]"); if (str.StartsWith("-ERR")) { str = null; } } } catch(Exception err) { lsttbxStatus.Items.Add("连接失败：[" + err.Message + "]"); } return str; } // 检查响应信息 private bool CheckResponse(string responseString) { if (responseString == null) { return false; } else { if (responseString.StartsWith("+OK")) { return true; } else { return false; } } } // 向服务器发送命令 private bool SendToServer(string str) { try { // 这里必须使用WriteLine方法的，因为POP3协议中定义的命令是以回车换行结束的 // 如果客户端发送的命令没有以回车换行结束，POP3服务器就不能识别，也就不能响应客户端的请求了 // 如果想用Write方法，则str输入的参数字符中必须包含"\r\n",也就是回车换行字符串。 streamWriter.WriteLine(str); streamWriter.Flush(); lsttbxStatus.Items.Add("发送：[" + str + "]"); return true; } catch(Exception ex) { lsttbxStatus.Items.Add("发送失败：[" + ex.Message + "]"); return false; } } #endregion 3.3 程序运行结果演示 首先输入邮箱名和密码登录到POP3服务器来获取邮件列表的演示：

Then select an email from the mailing list to read, and then demonstrate the operation of replying to the email (all messages can be sent with attachments):

The interface for reading email:

Interface for replying to emails:

At the same time, after clicking the send button, the mail can be sent to the SMTP server of sina, and then forwarded by the SMTP server of Sina to the SMTP server of QQ. The SMTP server of QQ in the POP3 server of QQ gets the received mail. When QQ users enter the correct mailbox name and password, they can get the received mail from the POP3 server of QQ.

Click the send button and successfully send the picture of the email:

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.