Trang 1 trên tổng số 3 123 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 23 kết quả

Đề tài: Gửi eMail với SMTP trong lập trình C#

  1. #1
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Mặc định Gửi eMail với SMTP trong lập trình C#

    Mỗi lần học được điều mới sẽ cố gắng chia sẻ mọi người ^^

    Hồi lâu nghiên cứu về cái SMTP cuối cùng cũng ngộ ra được 1 số thứ

    Giới thiệu qua chút về SMTP:

    SMTP là một giao thức dùng nền văn bản và tương đối đơn giản. Trước khi một thông điệp được gửi, người ta có thể định vị một hoặc nhiều địa chỉ nhận cho thông điệp - những địa chỉ này thường được kiểm tra về sự tồn tại trung thực của chúng) . Việc kiểm thử một trình chủ SMTP là một việc tương đối dễ dàng, dùng chương trình ứng dụng "telnet" (xem dưới đây).
    SMTP dùng cổng 25 của giao thức TCP. Để xác định trình chủ SMTP của một tên miền nào đấy (domain name), người ta dùng một mẫu tin MX (Mail eXchange - Trao đổi thư) của DNS (Domain Name System - Hệ thống tên miền).

    Các bạn nên đọc thêm tư liệu về SMTP
    Ref Links Code:

    Một ví dụ truy nhập trực tiếp vào mail server bằng telnet qua port 25:
    Output Code:
    1. S: 220 www.example.com ESMTP Postfix
    2. C: HELO mydomain.com
    3. S: 250 Hello mydomain.com
    4. C: MAIL FROM:<sender@mydomain.com>
    5. S: 250 Ok
    6. C: RCPT TO:<friend@example.com>
    7. S: 250 Ok
    8. C: DATA
    9. S: 354 End data with <CR><LF>.<CR><LF>
    10. C: Subject: test message
    11. C: From: sender@mydomain.com
    12. C: To: friend@example.com
    13. C:
    14. C: Hello,
    15. C: This is a test.
    16. C: Goodbye.
    17. C: .
    18. S: 250 Ok: queued as 12345
    19. C: QUIT
    20. S: 221 Bye
    21. Trích từ wikipedia Tiếng Việt: http://vi.wikipedia.org/wiki/SMTP

    Mình có làm một cái video bên HCE về cái này
    Code:
    http://hcegroup.net/hceteam/showthread.php?t=2497
    OK ! Xem thử mô hình nha





    Mô hình và cách thức như vậy ^^.

    [ Hết Phần 1 ]
    None!

  2. #2
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Thumbs down Cây dựng class MySMTP

    Đọc kĩ phần 1 nhé rồi sang phần 2 này

    Giờ ta tạo Class MySMTP để xử lý quy trình:

    Những thứ cần khởi tạo là gì? Dựa trên cái mô hình ở trên ta có những thứ sau

    Visual C# Code:
    1. private string Server;
    2. private string SenderName;
    3. private string SenderAddress;
    4. private string RCPName;
    5. private string RCPAddress;
    6. private string Subject;
    7. private int TimeOut;
    8. private int Port;
    9.  
    10. TcpClient SMTPTCPClient;
    11. NetworkStream SMTPNetworkStream;
    12. StreamReader SMTPStreamReader;
    13. StreamWriter SMTPStreamWriter;
    14. DateTime TimeOutCheck;

    Chú ý:
    + Để tạo một connection ta cần sử dụng: TcpClient
    + Để tạo một stream cho Network sử dụng NetworkStream
    + Xử lý NetworkStream qua 2 cái Base trước đó: StreamReader và StreamWriter.
    + DateTime: để quản lý connection , trường hợp bị TimeOut

    + Có các thành phần rồi giờ đơn giản thì ta tạo các Properties trước đi
    Visual C# Code:
    1. /*
    2.  * PROPERTIES
    3.  */
    4. // Property: Server
    5. public string SMTPServer
    6. {
    7.     get { return Server; }
    8.     set { Server = value; }
    9. }
    10. // Property: SenderName
    11. public string SMTPSenderName
    12. {
    13.     get { return SenderName; }
    14.     set { SenderName = value; }
    15. }
    16. // Property: SenderAddress
    17. public string SMTPSenderAddress
    18. {
    19.     get { return SenderAddress; }
    20.     set { SenderAddress = value; }
    21. }
    22. // Property: RCPName
    23. public string SMTPRCPName
    24. {
    25.     get { return RCPName; }
    26.     set { RCPName = value; }
    27. }
    28. // Property: RCPAddress
    29. public string SMTPRCPAddress
    30. {
    31.     get { return RCPAddress; }
    32.     set { RCPAddress = value; }
    33. }
    34. // Property: Subject
    35. public string SMTPSubject
    36. {
    37.     get { return Subject; }
    38.     set { Subject = value; }
    39. }
    40. // Property: Body
    41. public string SMTPBody
    42. {
    43.     get { return Body; }
    44.     set { Body = value; }
    45. }
    46. // Property: TimeOut
    47. public int SMTPTimeOut
    48. {
    49.     get { return TimeOut; }
    50.     set { TimeOut = value; }
    51. }
    52. // Property: Port
    53. public int SMTPPort
    54. {
    55.     get { return Port; }
    56.     set { Port = value; }
    57. }

    + Với xử lý việc gửi mail thì có thể chỉ cần sử dụng 1 phương thức:
    a. Gửi Email đi : OnSendEmail() là đủ
    Nhưng khi send Email ta cần kiểm tra connection time out vì thế phải xác nhận response từ server thì mới có thể request và biết nên đóng connection cho hợp lý. Vì vậy thêm 1 phương thức nữa xử lý TimeOut
    b. Xử lý Connection TimeOut: WaitForResponse()

    + Xử lý gửi thông điệp đi thực sự rất đơn giản và không phức tạp.
    Dựa vào mô hình ở trên ta thấy vòng lặp quá trình xử lý được làm như sau:
    Processes Code:
    1. 1. Khởi tạo kết nối, thất bại thì đóng
    2. 2. Khởi tạo thành công, thu nhận thông điệp vào các stream
    3. 3. Chào server, code = 220; đóng nếu thật bại
    4. 4. Xử lý sender address: đóng nếu thất bại . code =250
    5. 5. Xử lý người nhận : đóng nếu thất bại. code = 250
    6. 6. Xử lý data:
    7. Thông tin Data của thông điệp gửi đi có 2 phần chính:
    8. -- Header Info --
    9. From:
    10. To:
    11. Subject:
    12. -- Message Info --
    13. Body:
    14.  
    15. Ngoài ra còn một số thông tin khác bổ sung cho Header như DateTime, Reply-To....

    7. Gửi thông điệp , đóng nếu thất bại. Code = 354
    8. Kiểm tra thông điệp nếu được gửi thành công: code = 250. Đóng nếu thất bại

    Chú ý: việc xử lý các bước đều thông qua viẹc xử lý connection time out.
    Vì xử lý thông điệp tới server có 2 kết quả, thành công hoặc thất bại nên 2 phương thức ta viết ở sử dụng kiểu Boolean (bool)


    Từ bản nháp giấy trên ta tiến hành vào code thực dụng cho 2 phương thức:
    + public void OnSendEmail()
    + private void WaitForResponse(string Code) ( sử dụng private vì public thì ai dùng , có mỗi thằng OnSendEmail nó xài. Thêm vào đó Response code thì dùng kiểu String chứ không dùng Int vì tránh phải convert khi kiểm tra và so sánh từ stream. Thông điệp từ stream luôn là kiểu String).

    Đây là Class được xây dựng hoàn chỉnh:
    Visual C# Code:
    1. using System;
    2. using System.Collections.Generic;
    3. using System.IO;
    4. using System.Net;
    5. using System.Net.Sockets;
    6. using System.Text;
    7.  
    8. namespace Network
    9. {
    10.     public class MySMTP
    11.     {
    12.         // Mail Properties
    13.         private string Server;
    14.         private string SenderName;
    15.         private string SenderAddress;
    16.         private string RCPName;
    17.         private string RCPAddress;
    18.         private string Subject;
    19.         private string Body;
    20.         private int TimeOut;
    21.         private int Port;
    22.         // Network Connector Properties
    23.         TcpClient SMTPTCPClient;
    24.         NetworkStream SMTPNetworkStream;
    25.         StreamReader SMTPStreamReader;
    26.         StreamWriter SMTPStreamWriter;
    27.         DateTime TimeOutCheck;
    28.  
    29.         // Constructor
    30.         public MySMTP()
    31.         {
    32.             TimeOut = 60; // Set Connection Time Out around 1 minute
    33.             Port = 25; // which is accessed through Telnet
    34.         }
    35.  
    36.         /*
    37.          * PROPERTIES
    38.          */
    39.         // Property: Server
    40.         public string SMTPServer
    41.         {
    42.             get { return Server; }
    43.             set { Server = value; }
    44.         }
    45.         // Property: SenderName
    46.         public string SMTPSenderName
    47.         {
    48.             get { return SenderName; }
    49.             set { SenderName = value; }
    50.         }
    51.         // Property: SenderAddress
    52.         public string SMTPSenderAddress
    53.         {
    54.             get { return SenderAddress; }
    55.             set { SenderAddress = value; }
    56.         }
    57.         // Property: RCPName
    58.         public string SMTPRCPName
    59.         {
    60.             get { return RCPName; }
    61.             set { RCPName = value; }
    62.         }
    63.         // Property: RCPAddress
    64.         public string SMTPRCPAddress
    65.         {
    66.             get { return RCPAddress; }
    67.             set { RCPAddress = value; }
    68.         }
    69.         // Property: Subject
    70.         public string SMTPSubject
    71.         {
    72.             get { return Subject; }
    73.             set { Subject = value; }
    74.         }
    75.         // Property: Body
    76.         public string SMTPBody
    77.         {
    78.             get { return Body; }
    79.             set { Body = value; }
    80.         }
    81.         // Property: TimeOut
    82.         public int SMTPTimeOut
    83.         {
    84.             get { return TimeOut; }
    85.             set { TimeOut = value; }
    86.         }
    87.         // Property: Port
    88.         public int SMTPPort
    89.         {
    90.             get { return Port; }
    91.             set { Port = value; }
    92.         }
    93.  
    94.         /*
    95.          * METHOD
    96.          */
    97.  
    98.         // Send message through telnet connection
    99.         public bool OnSendEmail()
    100.         {
    101.             // Initialization
    102.             SMTPTCPClient = new TcpClient();
    103.             // Set up the connection
    104.             try
    105.             {
    106.                 SMTPTCPClient.Connect(Server, Port);
    107.             }
    108.             catch (Exception ex)
    109.             {
    110.                 // if fail to connect to mail server
    111.                 Console.WriteLine("Error: " + ex.Message);
    112.                 return false;
    113.             }
    114.             // If succeed creating the connection
    115.             // init all the streams
    116.             SMTPNetworkStream = SMTPTCPClient.GetStream();
    117.             SMTPStreamReader = new StreamReader(SMTPNetworkStream);
    118.             SMTPStreamWriter = new StreamWriter(SMTPNetworkStream);
    119.  
    120.             // Need for server's response
    121.             if (WaitForResponse("220"))
    122.             {
    123.                 // Greet mail server
    124.                 SMTPStreamWriter.WriteLine("HELO: " + Server);
    125.                 // Clear the rest/garbage
    126.                 SMTPStreamWriter.Flush();
    127.             }
    128.             else // if no response from server
    129.             {
    130.                 // connection fails
    131.                 SMTPTCPClient.Close();
    132.                 return false;
    133.             }
    134.  
    135.             // The next response for input sender address
    136.             if (WaitForResponse("250"))
    137.             {
    138.                 // write down the sender address
    139.                 SMTPStreamWriter.WriteLine("Mail From:" + SenderAddress);
    140.                 SMTPStreamWriter.Flush();
    141.             }
    142.             else
    143.             {
    144.                 // connection close otherwise
    145.                 SMTPTCPClient.Close();
    146.                 return false;
    147.             }
    148.  
    149.             // Response for input RCP Address
    150.             if (WaitForResponse("250"))
    151.             {
    152.                 // write down the RCP address
    153.                 SMTPStreamWriter.WriteLine("RCPT TO:" + RCPAddress);
    154.                 SMTPStreamWriter.Flush();
    155.             }
    156.             else
    157.             {
    158.                 // close the connection otherwise
    159.                 SMTPTCPClient.Close();
    160.                 return false;
    161.             }
    162.  
    163.             // Response for data / body
    164.             if (WaitForResponse("250"))
    165.             {
    166.                 // request data
    167.                 SMTPStreamWriter.WriteLine("Data");
    168.                 SMTPStreamWriter.Flush();
    169.             }
    170.             else
    171.             {
    172.                 // close connection otherwise
    173.                 SMTPTCPClient.Close();
    174.                 return false;
    175.             }
    176.  
    177.             // Send the message
    178.             if (WaitForResponse("354"))
    179.             {
    180.                 // Get all message
    181.                 // NOTE: Each section should be ended up with a newline seperately
    182.                 string szData = "";
    183.                 szData = "From:" + SenderName + Environment.NewLine;
    184.                 szData += "To:" + RCPName + Environment.NewLine;
    185.                 szData += "Subject:" + Subject + Environment.NewLine;
    186.                 szData += Body + Environment.NewLine + "." + Environment.NewLine;
    187.  
    188.                 // Send the message to network stream through stream writer
    189.                 SMTPStreamWriter.Write(szData);
    190.                 // clear the rest
    191.                 SMTPStreamWriter.Flush();
    192.             }
    193.             else
    194.             {
    195.                 // close the connection if fails
    196.                 SMTPTCPClient.Close();
    197.                 return false;
    198.             }
    199.  
    200.             // Wait for the last success
    201.             if (WaitForResponse("250"))
    202.             {
    203.                 // close the connection safely
    204.                 SMTPTCPClient.Close();
    205.                 return true;
    206.             }
    207.             else
    208.             {
    209.                 // close the connection otherwise
    210.                 SMTPTCPClient.Close();
    211.                 return false;
    212.             }
    213.         }
    214.  
    215.         // WaitForResponse method manipulates the connection response.
    216.         private bool WaitForResponse(string Code)
    217.         {
    218.             // Get the time at connecting moment
    219.             TimeOutCheck = DateTime.Now;
    220.             // Span the timer
    221.             TimeSpan TimeSpanner = DateTime.Now - TimeOutCheck;
    222.             // Loop until timeout exceeds
    223.             while (TimeSpanner.Seconds < TimeOut)
    224.             {
    225.                 if (SMTPNetworkStream.DataAvailable)
    226.                 {
    227.                     // If catch the incoming data, get it by lines
    228.                     string DataIn = SMTPStreamReader.ReadLine();
    229.                     // Check for the sufficient response code
    230.                     if (DataIn.Substring(0, Code.Length).Equals(Code))
    231.                         return true;                    
    232.                 }
    233.                 // Recalculate timeout
    234.                 TimeSpanner = DateTime.Now - TimeOutCheck;
    235.             }
    236.             // Return false if it fails
    237.             return false;
    238.         }
    239.     }
    240.  
    241.     public class Network
    242.     {
    243.         public static void Main()
    244.         {
    245.             // Create a SMTP Object
    246.             MySMTP smtp = new MySMTP();
    247.             smtp.SMTPServer = "gsmtp163.google.com";
    248.             smtp.SMTPPort = 25;
    249.             smtp.SMTPTimeOut = 60;
    250.             smtp.SMTPSenderName = "Pete Houston";
    251.             smtp.SMTPSenderAddress = "xcross87@gmail.com";
    252.             smtp.SMTPRCPName = "Pete Houston";
    253.             smtp.SMTPRCPAddress = "pete.houston.17187@gmail.com";
    254.             smtp.SMTPSubject = "Testing for SMTP Class";
    255.             smtp.SMTPBody = "Hello Pete ! Message Sent Successfully !";
    256.  
    257.             Console.WriteLine("Sending ... \n");
    258.             // Try to send email
    259.             if (smtp.OnSendEmail())
    260.             {
    261.                 Console.WriteLine("OK !");
    262.             }
    263.             else
    264.             {
    265.                 Console.WriteLine("Failed !");
    266.             }
    267.  
    268.         }
    269.     }
    270. }
    271.  
    272. // Ghi chú: có tham khảo và chỉnh sửa từ c-sharpcorner.com
    None!

  3. #3
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Thumbs down Dùng .NET Library xử lý với Mail Server

    Đọc 2 phần trên chắc hết phê với cái đống bùng nhùng SMTP và xử lý stream nhỉ

    Tuy nhiên .NET Framework đã có library hỗ trợ xử lý với các Mail Server

    thông qua
    Visual C# Code:
    1. using System.Net.Mail;
    2. public class SmtpClient;

    Để sử dụng ta đơn thuần tạo một Email Object từ class MailMessage trong cùng namespace System.Net.Mail;

    xử lý 4 properties chính của một Email Message:
    Form Code:
    1. From
    2. To
    3. Subject
    4. Body

    Một ví dụ send email qua SMTP như sau

    Visual C# Code:
    1. using System;
    2. using System.Net;
    3. using System.Net.Mail;
    4.  
    5. class EmailWithSMTP
    6. {  
    7.     // the EP
    8.     public static void Main() {
    9.         // server info
    10.         string szServer = "Dien server vao day";
    11.         int iPort = 25;
    12.        
    13.         // set up a connection
    14.         SmtpClient client = new SmtpClient(szServer,iPort);
    15.        
    16.         // If you access to a account on mail server to send email
    17.         // use this:
    18.         //  client.Credentials = new NetworkCredential("user@addr.com","password");
    19.        
    20.         // create message
    21.         using (MailMessage message = new MailMessage()) {
    22.             // make up message
    23.             message.From = new MailAddress("sender@somewhere.com");
    24.             message.To.Add("receiver@someplace.com");
    25.             message.Subject = "Testing email ";
    26.             message.Body = "Send successfully !";
    27.            
    28.             // send message
    29.             client.Send(message);
    30.         }
    31.     }
    32. }

    Đọc vào thì ai cũng hiểu cả

    Về phần SMTP chắc là kết thúc tại đây ..
    Sau này còn gì viết tiếp
    None!

  4. #4
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Khi check lại phần code ở trên khi truyền tải socket mình kiểm tra kết nối tới server chờ response, tuy nhiên rất hao tổn tài nguyên và chạy rất là rì rì.
    Mình sẽ viết lại theo hướng mới tuy nhiên cũng không có sự khác biệt nhiều lắm.

    1. Thử viết 1 class nho nhỏ xử lý việc gửi email trên Gmail Server
    2. Tạo thêm 1 class để catch Exception.
    3. Tạo danh sách CC,BCC để có thể gửi tới nhiều địa chỉ.

    OK ! Cùng đi vào làm việc nhé

    I. Đầu tiên cần xem xét một chút về Gmail Server đã.
    Mở Command Prompt ra (cmd.exe) rồi gõ
    Command Code:
    1. nslookup
    2. set type=mx
    3. gmail.com

    Kết quả sẽ được tạm như thế này
    Output Code:
    1. C:\Users\Xcross87>nslookup
    2. Default Server:  *****.*******.***
    3. Address:  ***.***.**.**:**
    4.  
    5. > set type=mx
    6. > gmail.com
    7. Server:  *****.*******.***
    8. Address:  ***.***.**.**:**
    9.  
    10. Non-authoritative answer:
    11. gmail.com       MX preference = 10, mail exchanger = alt1.gmail-smtp-in.l.google
    12. .com
    13. gmail.com       MX preference = 10, mail exchanger = alt2.gmail-smtp-in.l.google
    14. .com
    15. gmail.com       MX preference = 50, mail exchanger = gsmtp163.google.com
    16. gmail.com       MX preference = 50, mail exchanger = gsmtp183.google.com
    17. gmail.com       MX preference = 5, mail exchanger = gmail-smtp-in.l.google.com
    18.  
    19. gmail.com       nameserver = ns4.google.com
    20. gmail.com       nameserver = ns1.google.com
    21. gmail.com       nameserver = ns2.google.com
    22. gmail.com       nameserver = ns3.google.com
    23. gsmtp163.google.com     internet address = 64.233.163.27
    24. gsmtp183.google.com     internet address = 64.233.183.27
    25. > exit
    26.  
    27. C:\Users\Xcross87>

    như vậy là có thể thấy Gmail sử dụng các Email Exchange Server để lưu trữ và gửi mail đi.
    Tại sao lại sử dụng nhiều server mail như thế?
    Đơn giản là trong quá trình gửi mail đi nếu có trục trặc bị lỗi ở server này không gửi đi được thì mail sẽ được chuyển tới server khác để gửi.

    Ta sẽ chọn cái server có MX Preferences cao nhất để sử dụng vào code.

    II. Thử thí nghiệm 1 server bằng telnet xem server có làm việc hay không
    Đầu tiên ta chọn 1 server sau đó telnet
    Command Code:
    1. telnet gsmtp163.google.com 25
    và sẽ truy nhập được vào server và ta thử send 1 mail tới 1 Gmail account từ server này theo quy trình dưới đây.
    Output Code:
    1. 220 mx.google.com ESMTP f7si3180292nfh.26
    2. EHLO
    3. 250-mx.google.com at your service, [203.252.117.19]
    4. 250-SIZE 28311552
    5. 250-8BITMIME
    6. 250 ENHANCEDSTATUSCODES
    7. MAIL FROM: <xcross87@cviet.com>
    8. 250 2.1.0 OK
    9. RCPT TO: <pete.houston.17187@gmail.com>
    10. 250 2.1.5 OK
    11. DATA
    12. 354 Go ahead
    13. Subject: Testing Gmail
    14. From: Xcross87
    15. To: Pete Houston
    16. Content-Type: text/plain
    17. Message:
    18.  
    19. This is the message tesing from Mr.Pete
    20. Best Regards,
    21. .
    22. 250 2.0.0 OK 1201262899 f7si3180292nfh.26
    23. QUIT
    24. 221 2.0.0 mx.google.com closing connection f7si3180292nfh.26
    25. Connection to host lost.

    sau đó check email pete.houston.17187 @ gmail.com sẽ thấy một mail mới nhận.

    Các bạn thử thực hành quy trình trên bằng tay xem.

    [ Hết phần 4 ]
    None!

  5. #5
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Tiếp tục nào ...

    Trong quá trình send email đi ta chia nhỏ ra một chút.
    Ta sẽ chia ra phần gửi thông điệp tới server và sẽ kiểm tra response, nếu không hợp lệ thì sẽ throw vào lớp exception.
    Lý thuyết là thế, giờ bắt tay vào xây dựng cho hợp lý

    đầu tiên với exception, đơn giản chỉ cần xem server response là được
    Visual C# Code:
    1. public class SmtpException : System.Exception
    2. {
    3.     private string message;
    4.     public SmtpException(string str)
    5.     {
    6.         message = str;
    7.     }
    8.     public string What()
    9.     {
    10.         return message;
    11.     }
    12. }

    Ta tạo một namespace Gmail và tạo các class bên trong.
    Visual C# Code:
    1. using System;
    2. using System.Collections;
    3. using System.Net.Sockets;
    4. using System.Net.Mail;
    5. using System.Text;
    6.  
    7. namespace Gmail
    8. {
    9.        public class Smtp : TcpClient
    10.        public class SmtpException : Exception
    11. }

    Việc tiếp theo là thiết kế class Smtp
    Ta cài đặt với các properties như sau :
    Visual C# Code:
    1.  private string _server = null;
    2. private int _port = 0;
    3. private ArrayList _to;
    4. private ArrayList _cc;
    5. private ArrayList _bcc;
    6. private string _subject = null;
    7. private string _bodyHtml = null;
    8. private string _bodyText = null;
    9.  
    10. ///
    11. /// Constructor
    12. ///
    13.  
    14. public Smtp()
    15. {
    16.     // Init server connection info
    17.     _server = "gsmtp163.google.com";
    18.     _port = 25;
    19.  
    20.     // Init ArrayList
    21.     _to = new ArrayList();
    22.     _cc = new ArrayList();
    23.     _bcc = new ArrayList();
    24. }
    25.  
    26. ///
    27. /// Properties
    28. ///
    29.  
    30. public string Server
    31. {
    32.     get { return _server; }
    33.     set { _server = value; }
    34. }
    35. public int Port
    36. {
    37.     get { return _port; }
    38.     set { _port = value; }
    39. }
    40. {
    41.     get { return _from; }
    42.     set { _from = value; }
    43. }
    44. public ArrayList To
    45. {
    46.     get { return _to; }
    47.     set { _to = value; }
    48. }
    49. public ArrayList CC
    50. {
    51.     get { return _cc; }
    52.     set { _cc = value; }
    53. }
    54. public ArrayList BCC
    55. {
    56.     get { return _bcc; }
    57.     set { _bcc = value; }
    58. }
    59. public string Subject
    60. {
    61.     get { return _subject; }
    62.     set { _subject = value; }
    63. }
    64. public string BodyText
    65. {
    66.     get { return _bodyText; }
    67.     set { _bodyText = value; }
    68. }
    69. public string BodyHTML
    70. {
    71.     get { return _bodyHtml; }
    72.     set { _bodyHtml = value; }
    73. }

    [ Hết phần 5 ]
    None!

  6. #6
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Mặc định Phần 6

    Ta viết lại các method cho hoàn chỉnh
    Visual C# Code:
    1. #region { METHODS }
    2. ///
    3. /// Methods
    4. ///
    5.  
    6. // Write
    7. public void Write(string message)
    8. {
    9.     ASCIIEncoding en = new ASCIIEncoding();
    10.  
    11.     byte[] WriteBuffer = new byte[1024];
    12.     WriteBuffer = en.GetBytes(message);
    13.  
    14.     NetworkStream stream = GetStream();
    15.     stream.Write(WriteBuffer, 0, WriteBuffer.Length);
    16. }
    17.  
    18. // Response
    19. public string Response()
    20. {
    21.     ASCIIEncoding enc = new ASCIIEncoding();
    22.     byte[] serverbuff = new Byte[1024];
    23.     NetworkStream stream = GetStream();
    24.     int count = stream.Read(serverbuff, 0, 1024);
    25.     if (count == 0)
    26.         return "";
    27.     return enc.GetString(serverbuff, 0, count);
    28. }
    29.  
    30. // Send
    31. public void Send()
    32. {
    33.     string message;
    34.     string response;
    35.  
    36.     /*
    37.      * 1. Set up a connection to server and wait for welcome response
    38.      *      Code = 220
    39.      */      
    40.     Connect(server, 25);
    41.     response = Response();
    42.     if (response.Substring(0, 3) != "220")
    43.     {
    44.         throw new SmtpException(response);
    45.     };
    46.    
    47.     /*
    48.      * 2. Say greeting to server and wait for input
    49.      *      Code = 250
    50.      */
    51.     message = "HELO me\r\n";
    52.     Write(message);
    53.     response = Response();
    54.     if (response.Substring(0, 3) != "250")
    55.     {
    56.         throw new SmtpException(response);
    57.     }
    58.  
    59.     /*
    60.      * 3. Input sender address, just any
    61.      *      Code = 250
    62.      */
    63.     message = "MAIL FROM:<" + _from + ">\r\n";
    64.     Write(message);
    65.     response = Response();
    66.     if (response.Substring(0, 3) != "250")
    67.     {
    68.         throw new SmtpException(response);
    69.     }
    70.  
    71.     /*
    72.      * 4. Input list of receivers
    73.      *      Code = 250
    74.      */
    75.     foreach (string address in _to)
    76.     {
    77.         try
    78.         {
    79.             message = "RCPT TO:<" + address + ">\r\n";
    80.             Write(message);
    81.             response = Response();
    82.             if (response.Substring(0, 3) != "250")
    83.             {
    84.                 throw new SmtpException(response);
    85.             }
    86.         }
    87.         catch (SmtpException e)
    88.         {
    89.             System.Console.WriteLine("{0}", e.What());
    90.         }
    91.     }
    92.  
    93.     /*
    94.      * 5. Input list of cc
    95.      *      Code = 250
    96.      */
    97.     foreach (string address in _cc)
    98.     {
    99.         try
    100.         {
    101.             message = "RCPT TO:<" + address + ">\r\n";
    102.             Write(message);
    103.             response = Response();
    104.             if (response.Substring(0, 3) != "250")
    105.             {
    106.                 throw new SmtpException(response);
    107.             }
    108.         }
    109.         catch (SmtpException e)
    110.         {
    111.             System.Console.WriteLine("{ 0}", e.What());
    112.         }
    113.     }
    114.  
    115.     /*
    116.      * 6. Input list of bcc
    117.      *      Code = 250
    118.      */
    119.     foreach (string address in _bcc)
    120.     {
    121.         try
    122.         {
    123.             message = "RCPT TO:<" + address + ">\r\n";
    124.             Write(message);
    125.             response = Response();
    126.             if (response.Substring(0, 3) != "250")
    127.             {
    128.                 throw new SmtpException(response);
    129.             }
    130.         }
    131.         catch (SmtpException e)
    132.         {
    133.             System.Console.WriteLine("{ 0}", e.What());
    134.         }
    135.     }
    136.  
    137.     /*
    138.      * 7. Input data
    139.      *      Code = 354
    140.      */
    141.     message = "DATA\r\n";
    142.     Write(message);
    143.     response = Response();
    144.     if (response.Substring(0, 3) != "354")
    145.     {
    146.         throw new SmtpException(response);
    147.     }
    148.     // Subject
    149.     message = "Subject: " + subject + "\r\n";
    150.     // To
    151.     foreach (string address in _to)
    152.     {
    153.         message += "To: " + address + "\r\n";
    154.     }
    155.     // CC
    156.     foreach (string address in _cc)
    157.     {
    158.         message += "Cc: " + address + "\r\n";
    159.     }
    160.     // From
    161.     message += "From: " + _from + "\r\n";
    162.     // Content
    163.     if (bodyHtml.Length > 0)
    164.     {
    165.         message += "MIME-Version: 1.0\r\n"
    166.             + " Content-Type: text/ html;\r\n"
    167.             + " charset=\" iso-8859-1\"\r\n";
    168.         message += "\r\n" + bodyHtml;
    169.     }
    170.     else
    171.     {
    172.         message += "\r\n" + bodyText;
    173.     };
    174.     message += "\r\n.\r\n";
    175.    
    176.     /*
    177.      * 8. Send message
    178.      *      Code = 250
    179.      */
    180.     Write(message);
    181.     response = Response();
    182.     if (response.Substring(0, 3) != "250")
    183.     {
    184.         throw new SmtpException(response);
    185.     }
    186.  
    187.     /*
    188.      * 9. Quit
    189.      *      Code = 221
    190.      */
    191.     message = "QUIT\r\n";
    192.     Write(message);
    193.     response = Response();
    194.     if (response.IndexOf("221") == -1)
    195.     {
    196.         throw new SmtpException(response);
    197.     }
    198. }
    199.  
    200. #endregion
    None!

  7. #7
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Mặc định Phần 7

    việc cuôi cùng là test lại class cho hoàn chỉnh

    đây là bộ class hoàn chỉnh Smtp cho Gmail
    có cả 1 class con để test luôn

    Visual C# Code:
    1. using System;
    2. using System.Collections;
    3. using System.Collections.Generic;
    4. using System.Net.Sockets;
    5. using System.Net.Mail;
    6. using System.Text;
    7.  
    8. namespace Gmail
    9. {
    10.     public class Smtp : TcpClient
    11.     {
    12.         #region { VARIABLES LIST }
    13.         private string _server = null;
    14.         private int _port = 0;
    15.         private string _from = "";
    16.         private ArrayList _to;
    17.         private ArrayList _cc;
    18.         private ArrayList _bcc;
    19.         private string _subject = "";
    20.         private string _bodyHtml = "";
    21.         private string _bodyText = "";
    22.         #endregion
    23.  
    24.         #region { CONSTRUCTOR }
    25.         ///
    26.         /// Constructor
    27.         ///
    28.        
    29.         public Smtp()
    30.         {
    31.             // Init server connection info
    32.             _server = "gsmtp163.google.com";
    33.             _port = 25;
    34.  
    35.             // Init ArrayList
    36.             _to = new ArrayList();
    37.             _cc = new ArrayList();
    38.             _bcc = new ArrayList();
    39.         }
    40.         #endregion
    41.  
    42.         #region { PROPERTIES }
    43.         ///
    44.         /// Properties
    45.         ///
    46.  
    47.         public string Server
    48.         {
    49.             get { return _server; }
    50.             set { _server = value; }
    51.         }
    52.         public int Port
    53.         {
    54.             get { return _port; }
    55.             set { _port = value; }
    56.         }
    57.         public string From
    58.         {
    59.             get { return _from; }
    60.             set { _from = value; }
    61.         }
    62.         public ArrayList To
    63.         {
    64.             get { return _to; }
    65.             set { _to = value; }
    66.         }
    67.         public ArrayList CC
    68.         {
    69.             get { return _cc; }
    70.             set { _cc = value; }
    71.         }
    72.         public ArrayList BCC
    73.         {
    74.             get { return _bcc; }
    75.             set { _bcc = value; }
    76.         }
    77.         public string Subject
    78.         {
    79.             get { return _subject; }
    80.             set { _subject = value; }
    81.         }
    82.         public string BodyText
    83.         {
    84.             get { return _bodyText; }
    85.             set { _bodyText = value; }
    86.         }
    87.         public string BodyHTML
    88.         {
    89.             get { return _bodyHtml; }
    90.             set { _bodyHtml = value; }
    91.         }
    92.  
    93.         #endregion
    94.  
    95.         #region { METHODS }
    96.         ///
    97.         /// Methods
    98.         ///
    99.  
    100.         // Write
    101.         public void Write(string message)
    102.         {
    103.             ASCIIEncoding en = new ASCIIEncoding();
    104.  
    105.             byte[] WriteBuffer = new byte[1024];
    106.             WriteBuffer = en.GetBytes(message);
    107.  
    108.             NetworkStream stream = GetStream();
    109.             stream.Write(WriteBuffer, 0, WriteBuffer.Length);
    110.         }
    111.  
    112.         // Response
    113.         public string Response()
    114.         {
    115.             ASCIIEncoding enc = new ASCIIEncoding();
    116.             byte[] serverbuff = new Byte[1024];
    117.             NetworkStream stream = GetStream();
    118.             int count = stream.Read(serverbuff, 0, 1024);
    119.             if (count == 0)
    120.                 return "";
    121.             return enc.GetString(serverbuff, 0, count);
    122.         }
    123.  
    124.         // Send
    125.         public void Send()
    126.         {
    127.             string message = "";
    128.             string response;
    129.  
    130.             /*
    131.              * 1. Set up a connection to server and wait for welcome response
    132.              *      Code = 220
    133.              */      
    134.             Connect(_server, _port);
    135.             response = Response();
    136.             if (response.Substring(0, 3) != "220")
    137.             {
    138.                 throw new SmtpException(response);
    139.             };
    140.            
    141.             /*
    142.              * 2. Say greeting to server and wait for input
    143.              *      Code = 250
    144.              */
    145.             message = "HELO me\r\n";
    146.             Write(message);
    147.             response = Response();
    148.             if (response.Substring(0, 3) != "250")
    149.             {
    150.                 throw new SmtpException(response);
    151.             }
    152.  
    153.             /*
    154.              * 3. Input sender address, just any
    155.              *      Code = 250
    156.              */
    157.             message = "MAIL FROM:<" + _from + ">\r\n";
    158.             Write(message);
    159.             response = Response();
    160.             if (response.Substring(0, 3) != "250")
    161.             {
    162.                 throw new SmtpException(response);
    163.             }
    164.  
    165.             /*
    166.              * 4. Input list of receivers
    167.              *      Code = 250
    168.              */
    169.             foreach (string address in _to)
    170.             {
    171.                 try
    172.                 {
    173.                     message = "RCPT TO:<" + address + ">\r\n";
    174.                     Write(message);
    175.                     response = Response();
    176.                     if (response.Substring(0, 3) != "250")
    177.                     {
    178.                         throw new SmtpException(response);
    179.                     }
    180.                 }
    181.                 catch (SmtpException e)
    182.                 {
    183.                     System.Console.WriteLine("{0}", e.What());
    184.                 }
    185.             }
    186.  
    187.             /*
    188.              * 5. Input list of cc
    189.              *      Code = 250
    190.              */
    191.             foreach (string address in _cc)
    192.             {
    193.                 try
    194.                 {
    195.                     message = "RCPT TO:<" + address + ">\r\n";
    196.                     Write(message);
    197.                     response = Response();
    198.                     if (response.Substring(0, 3) != "250")
    199.                     {
    200.                         throw new SmtpException(response);
    201.                     }
    202.                 }
    203.                 catch (SmtpException e)
    204.                 {
    205.                     System.Console.WriteLine("{ 0}", e.What());
    206.                 }
    207.             }
    208.  
    209.             /*
    210.              * 6. Input list of bcc
    211.              *      Code = 250
    212.              */
    213.             foreach (string address in _bcc)
    214.             {
    215.                 try
    216.                 {
    217.                     message = "RCPT TO:<" + address + ">\r\n";
    218.                     Write(message);
    219.                     response = Response();
    220.                     if (response.Substring(0, 3) != "250")
    221.                     {
    222.                         throw new SmtpException(response);
    223.                     }
    224.                 }
    225.                 catch (SmtpException e)
    226.                 {
    227.                     System.Console.WriteLine("{ 0}", e.What());
    228.                 }
    229.             }
    230.  
    231.             /*
    232.              * 7. Input data
    233.              *      Code = 354
    234.              */
    235.             message = "DATA\r\n";
    236.             Write(message);
    237.             response = Response();
    238.             if (response.Substring(0, 3) != "354")
    239.             {
    240.                 throw new SmtpException(response);
    241.             }
    242.             // Subject
    243.             message = "Subject: " + _subject + "\r\n";
    244.             // To
    245.             foreach (string address in _to)
    246.             {
    247.                 message += "To: " + address + "\r\n";
    248.             }
    249.             // CC
    250.             foreach (string address in _cc)
    251.             {
    252.                 message += "Cc: " + address + "\r\n";
    253.             }
    254.             // From
    255.             message += "From: " + _from + "\r\n";
    256.             // Content
    257.             if (_bodyHtml.Length > 0)
    258.             {
    259.                 message += "MIME-Version: 1.0\r\n"
    260.                     + " Content-Type: text/ html;\r\n"
    261.                     + " charset=\" iso-8859-1\"\r\n";
    262.                 message += "\r\n" + _bodyHtml;
    263.             }
    264.             else
    265.             {
    266.                 message += "\r\n" + _bodyText;
    267.             };
    268.             message += "\r\n.\r\n";
    269.            
    270.             /*
    271.              * 8. Send message
    272.              *      Code = 250
    273.              */
    274.             Write(message);
    275.             response = Response();
    276.             if (response.Substring(0, 3) != "250")
    277.             {
    278.                 throw new SmtpException(response);
    279.             }
    280.  
    281.             /*
    282.              * 9. Quit
    283.              *      Code = 221
    284.              */
    285.             message = "QUIT\r\n";
    286.             Write(message);
    287.             response = Response();
    288.             if (response.IndexOf("221") == -1)
    289.             {
    290.                 throw new SmtpException(response);
    291.             }
    292.         }
    293.  
    294.         #endregion
    295.     }
    296.     public class SmtpException : Exception
    297.     {
    298.         string message;
    299.         public SmtpException(string str)
    300.         {
    301.             message = str;
    302.         }
    303.         public string What()
    304.         {
    305.             return message;
    306.         }
    307.     }
    308.     public class SMTPTest
    309.     {
    310.         public static void Main(string[] args)
    311.         {
    312.             try
    313.             {
    314.                 Smtp smtp = new Smtp();                
    315.                 smtp.From = "xcross87@cviet.com";
    316.                 smtp.Subject = "Greet to Pete";
    317.                 smtp.BodyText = "How's your work going?";
    318.                 smtp.To.Add("pete.houston.17187@gmail.com");
    319.                 smtp.Send();
    320.             }
    321.             catch (SmtpException e)
    322.             {
    323.                 System.Console.WriteLine("{0}", e.What());
    324.             }
    325.         }
    326.     }
    327. }

    rất đơn giản phải không
    giờ bạn chỉ cần thêm 1 class POP3 cho Gmail nữa là có được 1 namespace Gmail để xử lý việc gửi và nhận mail trong gmail rồi ^^
    None!

  8. #8
    Ngày gia nhập
    09 2006
    Nơi ở
    /usr/share/.hack@
    Bài viết
    1,433

    Thumbs down Phần 8

    Xem lại thì thấy code nó hơi lằng nhằng nên sửa lại mấy cái response code thành cái enum cho dễ làm việc

    Visual C# Code:
    1. public enum SmtpResponseCode: int {
    2.     CONNECT_SUCCESS = 220,
    3.     GENERIC_SUCCESS = 250,
    4.     DATA_SUCCESS    = 354,
    5.     QUIT_SUCCESS    = 221
    6. }

    ở đoạn check response có thể dich ngược lại kiểu Int hoặc sang string (toString())

    None!

  9. #9
    Ngày gia nhập
    02 2009
    Bài viết
    7

    cho tớ hỏi, cách gửi mail thông qua việc dùng lớp TcpClient (kế thừa) và StmpClient khác nhau ở điểm nào ? và tại sao lại làm thế ? Thanks
    Hỡi thế gian tiền ở đâu ?
    Khiến ta than khóc thảm sầu
    Trời Nam, đất Bắc khôn tìm kiếm
    Tiền ơi, tiền hỡi rơi xuống đầu ta đi ...

  10. #10
    Ngày gia nhập
    12 2008
    Bài viết
    43

    làm lại ko được thế mới đểu chứ

Các đề tài tương tự

  1. Attach File Khi gửi Email qua SMTP?
    Gửi bởi trần trân trong diễn đàn Windows API, Hooking, xử lý Windows Message
    Trả lời: 1
    Bài viết cuối: 23-04-2013, 12:58 PM
  2. Những thứ cần thiết để viết một ứng dụng email client(SMTP, POP,IMAP)
    Gửi bởi letuandung83 trong diễn đàn Thắc mắc lập trình Visual C++
    Trả lời: 2
    Bài viết cuối: 10-01-2012, 04:20 PM
  3. Thắc mắc smtp.EnableSsl trong gửi mail với C#
    Gửi bởi chuchodom trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 4
    Bài viết cuối: 31-05-2011, 09:29 AM
  4. Lỗi: hàm sendmail qua smtp, sử dụng google email
    Gửi bởi thansautk trong diễn đàn Thắc mắc lập trình C#
    Trả lời: 5
    Bài viết cuối: 31-08-2010, 10:09 PM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn