Discuz!NT 2.6的FTP和email类

Email类

当前路径：/CodeFile/dnt26/Discuz.Plugin/Mail/SmtpMail.cs.html
using System;
using System.Text;
using System.Collections;
using System.Net.Sockets;
using System.Web.Mail;
using System.Net;

namespace Discuz.Plugin.Mail
{
	
	#region Discuz!NT邮件发送程序

    /// <summary>
    /// Discuz!NT邮件发送程序
    /// </summary>
    [SmtpEmail("Discuz!NT邮件发送程序", Version = "2.0", Author = "Discuz!NT ", DllFileName = "Discuz.PlugIn.dll")]
	public class SmtpMail: ISmtpMail
	{

		private string enter = "\r\n";

		/// <summary>
		/// 设定语言代码,默认设定为GB2312,如不需要可设置为""
		/// </summary>
		private string _charset = "GB2312";

		/// <summary>
		/// 发件人地址
		/// </summary>
		private string _from = "";

		/// <summary>
		/// 发件人姓名
		/// </summary>
		private string _fromName = "";

		/// <summary>
		/// 回复邮件地址
		/// </summary>
		///public string ReplyTo="";

		/// <summary>
		/// 收件人姓名
		/// </summary>	
		private string _recipientName = "";

		/// <summary>
		/// 收件人列表
		/// </summary>
		private Hashtable Recipient = new Hashtable();

		/// <summary>
		/// 邮件服务器域名
		/// </summary>	
		private string mailserver = "";

		/// <summary>
		/// 邮件服务器端口号
		/// </summary>	
		private int mailserverport = 25;

		/// <summary>
		/// SMTP认证时使用的用户名
		/// </summary>
		private string username = "";

		/// <summary>
		/// SMTP认证时使用的密码
		/// </summary>
		private string password = "";

		/// <summary>
		/// 是否需要SMTP验证
		/// </summary>		
		private bool ESmtp = false;

		/// <summary>
		/// 是否Html邮件
		/// </summary>		
		private bool _html = false;


		/// <summary>
		/// 邮件附件列表
		/// </summary>
		private IList Attachments;

		/// <summary>
		/// 邮件发送优先级,可设置为"High","Normal","Low"或"1","3","5"
		/// </summary>
		private string priority = "Normal";

		/// <summary>
		/// 邮件主题
		/// </summary>		
		private string _subject;

		/// <summary>
		/// 邮件正文
		/// </summary>		
		private string _body;
        
		/// <summary>
		/// 密送收件人列表
		/// </summary>
		///private Hashtable RecipientBCC=new Hashtable();

		/// <summary>
		/// 收件人数量
		/// </summary>
		private int RecipientNum = 0;

		/// <summary>
		/// 最多收件人数量
		/// </summary>
		private int recipientmaxnum = 5;

		/// <summary>
		/// 密件收件人数量
		/// </summary>
		///private int RecipientBCCNum=0;

		/// <summary>
		/// 错误消息反馈
		/// </summary>
		private string errmsg;

		/// <summary>
		/// TcpClient对象,用于连接服务器
		/// </summary>	
		private TcpClient tc;

		/// <summary>
		/// NetworkStream对象
		/// </summary>	
		private NetworkStream ns;
		
		/// <summary>
		/// 服务器交互记录
		/// </summary>
		private string logs = "";

		/// <summary>
		/// SMTP错误代码哈希表
		/// </summary>
		private Hashtable ErrCodeHT = new Hashtable();

		/// <summary>
		/// SMTP正确代码哈希表
		/// </summary>
		private Hashtable RightCodeHT = new Hashtable();
		

		/// <summary>
		/// </summary>
		public SmtpMail()
		{
			Attachments = new System.Collections.ArrayList();
			SMTPCodeAdd();
		}

		#region Properties


		/// <summary>
		/// 邮件主题
		/// </summary>
		public string Subject
		{
			get
			{
				return this._subject;
			}
			set
			{
				this._subject = value;
			}
		}

		/// <summary>
		/// 邮件正文
		/// </summary>
		public string Body
		{
			get
			{
				return this._body;
			}
			set
			{
				this._body = value;
			}
		}

		
		/// <summary>
		/// 发件人地址
		/// </summary>
		public string From
		{
			get
			{
				return _from;
			}
			set
			{
				this._from = value;
			}
		}

		/// <summary>
		/// 设定语言代码,默认设定为GB2312,如不需要可设置为""
		/// </summary>
		public string Charset
		{
			get
			{
				return this._charset;
			}
			set
			{
				this._charset = value;
			}
		}

		/// <summary>
		/// 发件人姓名
		/// </summary>
		public string FromName
		{
			get
			{
				return this._fromName;
			}
			set
			{
				this._fromName = value;
			}
		}

		/// <summary>
		/// 收件人姓名
		/// </summary>
		public string RecipientName
		{
			get
			{
				return this._recipientName;
			}
			set
			{
				this._recipientName = value;
			}
		}
		
		/// <summary>
		/// 邮件服务器域名和验证信息
		/// 形如："user:pass@www.server.com:25",也可省略次要信息。如"user:pass@www.server.com"或"www.server.com"
		/// </summary>	
		public string MailDomain
		{
			set
			{
				string maidomain = value.Trim();
				int tempint;

				if(maidomain != "")
				{
					tempint = maidomain.IndexOf("@");
					if(tempint != -1)
					{
						string str = maidomain.Substring(0,tempint);
						MailServerUserName = str.Substring(0,str.IndexOf(":"));
						MailServerPassWord = str.Substring(str.IndexOf(":") + 1,str.Length - str.IndexOf(":") - 1);
						maidomain = maidomain.Substring(tempint + 1,maidomain.Length - tempint - 1);
					}

					tempint = maidomain.IndexOf(":");
					if(tempint != -1)
					{
						mailserver = maidomain.Substring(0,tempint);
						mailserverport = System.Convert.ToInt32(maidomain.Substring(tempint + 1,maidomain.Length - tempint - 1));
					}
					else
					{
						mailserver = maidomain;

					}

					
				}

			}
		}



		/// <summary>
		/// 邮件服务器端口号
		/// </summary>	
		public int MailDomainPort
		{
			set
			{
				mailserverport = value;
			}
		}



		/// <summary>
		/// SMTP认证时使用的用户名
		/// </summary>
		public string MailServerUserName
		{
			set
			{
				if(value.Trim() != "")
				{
					username = value.Trim();
					ESmtp = true;
				}
				else
				{
					username = "";
					ESmtp = false;
				}
			}
		}

		/// <summary>
		/// SMTP认证时使用的密码
		/// </summary>
		public string MailServerPassWord
		{
			set
			{
				password = value;
			}
		}	


		public string ErrCodeHTMessage(string code)
		{
			return ErrCodeHT[code].ToString();
		}
		/// <summary>
		/// 邮件发送优先级,可设置为"High","Normal","Low"或"1","3","5"
		/// </summary>
		public string Priority
		{
			set
			{
				switch(value.ToLower())
				{
					case "high":
						priority = "High";
						break;

					case "1":
						priority = "High";
						break;

					case "normal":
						priority = "Normal";
						break;

					case "3":
						priority = "Normal";
						break;

					case "low":
						priority = "Low";
						break;

					case "5":
						priority = "Low";
						break;

					default:
						priority = "High";
						break;
				}
			}
		}

		/// <summary>
		///  是否Html邮件
		/// </summary>
		public bool Html
		{
			get
			{
				return this._html;
			}
			set
			{
				this._html = value;
			}
		}


		/// <summary>
		/// 错误消息反馈
		/// </summary>		
		public string ErrorMessage
		{
			get
			{
				return errmsg;
			}
		}

		/// <summary>
		/// 服务器交互记录
		/// </summary>
		public string Logs
		{
			get
			{
				return logs;
			}
		}

		/// <summary>
		/// 最多收件人数量
		/// </summary>
		public int RecipientMaxNum
		{
			set
			{
				recipientmaxnum = value;
			}
		}

		
		#endregion

		#region Methods


		/// <summary>
		/// 添加邮件附件
		/// </summary>
		/// <param name="FilePath">附件绝对路径</param>
		public void AddAttachment(params string[] FilePath)
		{
			if(FilePath == null)
			{
				throw(new ArgumentNullException("FilePath"));
			}
			for(int i = 0; i < FilePath.Length; i++)
			{
				Attachments.Add(FilePath[i]);
			}
		}
		
		/// <summary>
		/// 添加一组收件人(不超过recipientmaxnum个),参数为字符串数组
		/// </summary>
		/// <param name="Recipients">保存有收件人地址的字符串数组(不超过recipientmaxnum个)</param>	
		public bool AddRecipient(params string[] Recipients)
		{
			if(Recipient == null)
			{
				Dispose();
				throw(new ArgumentNullException("Recipients"));
			}
			for(int i = 0; i < Recipients.Length; i++)
			{
				string recipient = Recipients[i].Trim();
				if(recipient == String.Empty)
				{
					Dispose();
					throw new ArgumentNullException("Recipients["+ i +"]");
				}
				if(recipient.IndexOf("@") == -1)
				{
					Dispose();
					throw new ArgumentException("Recipients.IndexOf(\"@\")==-1","Recipients");
				}
				if(!AddRecipient(recipient))
				{
					return false;
				}
			}
			return true;
		}

		/// <summary>
		/// 发送邮件方法,所有参数均通过属性设置。
		/// </summary>
		public bool Send()
		{
			if(mailserver.Trim() == "")
			{
				throw(new ArgumentNullException("Recipient","必须指定SMTP服务器"));
			}

			return SendEmail();
			
		}


		/// <summary>
		/// 发送邮件方法
		/// </summary>
		/// <param name="smtpserver">smtp服务器信息,如"username:password@www.smtpserver.com:25",也可去掉部分次要信息,如"www.smtpserver.com"</param>
		public bool Send(string smtpserver)
		{			
			MailDomain = smtpserver;
			return Send();
		}


		/// <summary>
		/// 发送邮件方法
		/// </summary>
		/// <param name="smtpserver">smtp服务器信息,如"username:password@www.smtpserver.com:25",也可去掉部分次要信息,如"www.smtpserver.com"</param>
		/// <param name="from">发件人mail地址</param>
		/// <param name="fromname">发件人姓名</param>
		/// <param name="to">收件人地址</param>
		/// <param name="toname">收件人姓名</param>
		/// <param name="html">是否HTML邮件</param>
		/// <param name="subject">邮件主题</param>
		/// <param name="body">邮件正文</param>
		public bool Send(string smtpserver,string from,string fromname,string to,string toname,bool html,string subject,string body)
		{
			MailDomain = smtpserver;
			From = from;
			FromName = fromname;
			AddRecipient(to);
			RecipientName = toname;
			Html = html;
			Subject = subject;
			Body = body;
			return Send();
		}
		

		#endregion

		#region Private Helper Functions

		/// <summary>
		/// 添加一个收件人
		/// </summary>	
		/// <param name="Recipients">收件人地址</param>
		private bool AddRecipient(string Recipients)
		{
			//修改等待邮件验证的用户重复发送的问题
			Recipient.Clear();
			RecipientNum = 0;
			if(RecipientNum<recipientmaxnum)
			{
				Recipient.Add(RecipientNum,Recipients);
				RecipientNum++;				
				return true;
			}
			else
			{
				Dispose();
				throw(new ArgumentOutOfRangeException("Recipients","收件人过多不可多于 "+ recipientmaxnum  +" 个"));
			}
		}

		void Dispose()
		{
			if(ns != null)
				ns.Close();
			if(tc != null)
				tc.Close();
		}

		/// <summary>
		/// SMTP回应代码哈希表
		/// </summary>
		private void SMTPCodeAdd()
		{
			ErrCodeHT.Add("500","邮箱地址错误");
			ErrCodeHT.Add("501","参数格式错误");
			ErrCodeHT.Add("502","命令不可实现");
			ErrCodeHT.Add("503","服务器需要SMTP验证");
			ErrCodeHT.Add("504","命令参数不可实现");
			ErrCodeHT.Add("421","服务未就绪,关闭传输信道");
			ErrCodeHT.Add("450","要求的邮件操作未完成,邮箱不可用(例如,邮箱忙)");
			ErrCodeHT.Add("550","要求的邮件操作未完成,邮箱不可用(例如,邮箱未找到,或不可访问)");
			ErrCodeHT.Add("451","放弃要求的操作;处理过程中出错");
			ErrCodeHT.Add("551","用户非本地,请尝试<forward-path>");
			ErrCodeHT.Add("452","系统存储不足, 要求的操作未执行");
			ErrCodeHT.Add("552","过量的存储分配, 要求的操作未执行");
			ErrCodeHT.Add("553","邮箱名不可用, 要求的操作未执行(例如邮箱格式错误)");
			ErrCodeHT.Add("432","需要一个密码转换");
			ErrCodeHT.Add("534","认证机制过于简单");
			ErrCodeHT.Add("538","当前请求的认证机制需要加密");
			ErrCodeHT.Add("454","临时认证失败");
			ErrCodeHT.Add("530","需要认证");

			RightCodeHT.Add("220","服务就绪");
			RightCodeHT.Add("250","要求的邮件操作完成");
			RightCodeHT.Add("251","用户非本地, 将转发向<forward-path>");
			RightCodeHT.Add("354","开始邮件输入, 以<enter>.<enter>结束");
			RightCodeHT.Add("221","服务关闭传输信道");
			RightCodeHT.Add("334","服务器响应验证Base64字符串");
			RightCodeHT.Add("235","验证成功");
		}


		/// <summary>
		/// 将字符串编码为Base64字符串
		/// </summary>
		/// <param name="str">要编码的字符串</param>
		private string Base64Encode(string str)
		{
			byte[] barray;
			barray = Encoding.Default.GetBytes(str);
			return Convert.ToBase64String(barray);
		}


		/// <summary>
		/// 将Base64字符串解码为普通字符串
		/// </summary>
		/// <param name="str">要解码的字符串</param>
		private string Base64Decode(string str)
		{
			byte[] barray;
			barray = Convert.FromBase64String(str);
			return Encoding.Default.GetString(barray);
		}

		
		/// <summary>
		/// 得到上传附件的文件流
		/// </summary>
		/// <param name="FilePath">附件的绝对路径</param>
		private string GetStream(string FilePath)
		{
			//建立文件流对象
			System.IO.FileStream FileStr = new System.IO.FileStream(FilePath,System.IO.FileMode.Open);
			byte[] by = new byte[System.Convert.ToInt32(FileStr.Length)];
			FileStr.Read(by,0,by.Length);
			FileStr.Close();
			return(System.Convert.ToBase64String(by));
		}

		/// <summary>
		/// 发送SMTP命令
		/// </summary>	
		private bool SendCommand(string str)
		{
			byte[]  WriteBuffer;
			if(str == null || str.Trim() == String.Empty)
			{
				return true;
			}
			logs += str;
			WriteBuffer = Encoding.Default.GetBytes(str);
			try
			{
				ns.Write(WriteBuffer,0,WriteBuffer.Length);
			}
			catch
			{
				errmsg = "网络连接错误";
				return false;
			}
			return true;
		}

		/// <summary>
		/// 接收SMTP服务器回应
		/// </summary>
		private string RecvResponse()
		{
			int StreamSize;
			string ReturnValue = String.Empty;
			byte[]  ReadBuffer = new byte[1024] ;
			try
			{
				StreamSize = ns.Read(ReadBuffer,0,ReadBuffer.Length);
			}
			catch
			{
				errmsg = "网络连接错误";
				return "false";
			}

			if (StreamSize == 0)
			{
				return ReturnValue ;
			}
			else
			{
				ReturnValue = Encoding.Default.GetString(ReadBuffer).Substring(0,StreamSize);
				logs += ReturnValue + this.enter;
				return ReturnValue;
			}
		}

		/// <summary>
		/// 与服务器交互,发送一条命令并接收回应。
		/// </summary>
		/// <param name="str">一个要发送的命令</param>
		/// <param name="errstr">如果错误,要反馈的信息</param>
		private bool Dialog(string str,string errstr)
		{
			if(str == null||str.Trim() == "")
			{
				return true;
			}
			if(SendCommand(str))
			{
				string RR = RecvResponse();
				if(RR == "false")
				{
					return false;
				}
				string RRCode = RR.Substring(0,3);
				if(RightCodeHT[RRCode] != null)
				{
					return true;
				}
				else
				{
					if(ErrCodeHT[RRCode] != null)
					{
						errmsg += (RRCode+ErrCodeHT[RRCode].ToString());
						errmsg += enter;
					}
					else
					{
						errmsg += RR;
					}
					errmsg += errstr;
					return false;
				}
			}
			else
			{
				return false;
			}

		}


		/// <summary>
		/// 与服务器交互,发送一组命令并接收回应。
		/// </summary>

		private bool Dialog(string[] str,string errstr)
		{
			for(int i = 0; i < str.Length; i++)
			{
				if(!Dialog(str[i],""))
				{
					errmsg += enter;
					errmsg += errstr;
					return false;
				}
			}

			return true;
		}

		/// <summary>
		/// SendEmail
		/// </summary>
		/// <returns></returns>
		private bool SendEmail()
		{
			//连接网络
			try
			{
				tc = new TcpClient(mailserver,mailserverport);
			}
			catch(Exception e)
			{
				errmsg = e.ToString();
				return false;
			}

			ns = tc.GetStream();
		

			//验证网络连接是否正确
			if(RightCodeHT[RecvResponse().Substring(0,3)] == null)
			{
				errmsg = "网络连接失败";
				return false;
			}


			string[] SendBuffer;
			string SendBufferstr;

			//进行SMTP验证
			if(ESmtp)
			{
				SendBuffer = new String[4];
				SendBuffer[0] = "EHLO " + mailserver + enter;
				SendBuffer[1] = "AUTH LOGIN" + enter;
				SendBuffer[2] = Base64Encode(username) + enter;
				SendBuffer[3] = Base64Encode(password) + enter;
				if(!Dialog(SendBuffer,"SMTP服务器验证失败,请核对用户名和密码。"))
					return false;
			}
			else
			{
				SendBufferstr = "HELO " + mailserver + enter;
				if(!Dialog(SendBufferstr,""))
					return false;
			}

			//
			SendBufferstr = "MAIL FROM:<" + From + ">" + enter;
			if(!Dialog(SendBufferstr,"发件人地址错误,或不能为空"))
				return false;

			//
			SendBuffer = new string[recipientmaxnum];
			for(int i = 0; i < Recipient.Count; i++)
			{
				SendBuffer[i] = "RCPT TO:<" + Recipient[i].ToString() + ">" + enter;

			}
			if(!Dialog(SendBuffer,"收件人地址有误"))
				return false;

			/*
						SendBuffer=new string[10];
						for(int i=0;i<RecipientBCC.Count;i++)
						{

							SendBuffer[i]="RCPT TO:<" + RecipientBCC[i].ToString() +">" + enter;

						}

						if(!Dialog(SendBuffer,"密件收件人地址有误"))
							return false;
			*/
			SendBufferstr = "DATA" + enter;
			if(!Dialog(SendBufferstr,""))
				return false;

			SendBufferstr = "From:" + FromName + "<" + From + ">" +enter;

			//if(ReplyTo.Trim()!="")
			//{
			//	SendBufferstr+="Reply-To: " + ReplyTo + enter;
			//}

            //SendBufferstr += "To:" + (Discuz.Common.Utils.StrIsNullOrEmpty(RecipientName)?"":Base64Encode(RecipientName)) + "<" + Recipient[0] + ">" + enter;
            SendBufferstr += "To:=?" + Charset.ToUpper() + "?B?" + (Discuz.Common.Utils.StrIsNullOrEmpty(RecipientName) ? "" : Base64Encode(RecipientName)) + "?=" + "<" + Recipient[0] + ">" + enter;
			
            //注释掉抄送代码
            SendBufferstr += "CC:";
            for (int i = 1; i < Recipient.Count; i++)
            {
                SendBufferstr += Recipient[i].ToString() + "<" + Recipient[i].ToString() + ">,";
            }
			SendBufferstr += enter;

			SendBufferstr += ((Subject==String.Empty || Subject==null)?"Subject:":((Charset=="")?("Subject:" + Subject):("Subject:" + "=?" + Charset.ToUpper() + "?B?" + Base64Encode(Subject) +"?="))) + enter;
			SendBufferstr += "X-Priority:" + priority + enter;
			SendBufferstr += "X-MSMail-Priority:" + priority + enter;
			SendBufferstr += "Importance:" + priority + enter;
			SendBufferstr += "X-Mailer: Lion.Web.Mail.SmtpMail Pubclass [cn]" + enter;
			SendBufferstr += "MIME-Version: 1.0" + enter;
			if(Attachments.Count != 0)
			{
				SendBufferstr += "Content-Type: multipart/mixed;" + enter;
				SendBufferstr += "	boundary=\"=====" + (Html?"001_Dragon520636771063_":"001_Dragon303406132050_") + "=====\"" + enter + enter;
			}

			if(Html)
			{
				if(Attachments.Count == 0)
				{
					SendBufferstr += "Content-Type: multipart/alternative;" + enter;//内容格式和分隔符
					SendBufferstr += "	boundary=\"=====003_Dragon520636771063_=====\"" + enter + enter;

					SendBufferstr += "This is a multi-part message in MIME format." + enter + enter;
				}
				else
				{
					SendBufferstr += "This is a multi-part message in MIME format." + enter + enter;
					SendBufferstr += "--=====001_Dragon520636771063_=====" + enter;
					SendBufferstr += "Content-Type: multipart/alternative;" + enter;//内容格式和分隔符
					SendBufferstr += "	boundary=\"=====003_Dragon520636771063_=====\"" + enter + enter;					
				}
				SendBufferstr += "--=====003_Dragon520636771063_=====" + enter;
				SendBufferstr += "Content-Type: text/plain;" + enter;
				SendBufferstr += ((Charset=="")?("	charset=\"iso-8859-1\""):("	charset=\"" + Charset.ToLower() + "\"")) + enter;
				SendBufferstr += "Content-Transfer-Encoding: base64" + enter + enter;
				SendBufferstr += Base64Encode("邮件内容为HTML格式,请选择HTML方式查看") + enter + enter;

				SendBufferstr += "--=====003_Dragon520636771063_=====" + enter;

				

				SendBufferstr += "Content-Type: text/html;" + enter;
				SendBufferstr += ((Charset=="")?("	charset=\"iso-8859-1\""):("	charset=\"" + Charset.ToLower() + "\"")) + enter;
				SendBufferstr += "Content-Transfer-Encoding: base64" + enter + enter;
				SendBufferstr += Base64Encode(Body) + enter + enter;
				SendBufferstr += "--=====003_Dragon520636771063_=====--" + enter;
			}
			else
			{
				if(Attachments.Count!=0)
				{
					SendBufferstr += "--=====001_Dragon303406132050_=====" + enter;
				}
				SendBufferstr += "Content-Type: text/plain;" + enter;
				SendBufferstr += ((Charset=="")?("	charset=\"iso-8859-1\""):("	charset=\"" + Charset.ToLower() + "\"")) + enter;
				SendBufferstr += "Content-Transfer-Encoding: base64" + enter + enter;
				SendBufferstr += Base64Encode(Body) + enter;
			}
			
			//SendBufferstr += "Content-Transfer-Encoding: base64"+enter;

			

			
			if(Attachments.Count != 0)
			{
				for(int i = 0; i < Attachments.Count; i++)
				{
					string filepath = (string)Attachments[i];
					SendBufferstr += "--=====" + (Html?"001_Dragon520636771063_":"001_Dragon303406132050_") + "=====" + enter;
					//SendBufferstr += "Content-Type: application/octet-stream"+enter;
					SendBufferstr += "Content-Type: text/plain;" + enter;
					SendBufferstr += "	name=\"=?" + Charset.ToUpper() + "?B?" + Base64Encode(filepath.Substring(filepath.LastIndexOf("\\")+1)) + "?=\"" + enter;
					SendBufferstr += "Content-Transfer-Encoding: base64" + enter;
					SendBufferstr += "Content-Disposition: attachment;" + enter;
					SendBufferstr += "	filename=\"=?" + Charset.ToUpper() + "?B?" + Base64Encode(filepath.Substring(filepath.LastIndexOf("\\")+1)) + "?=\"" + enter + enter;
					SendBufferstr += GetStream(filepath) + enter + enter;
				}
				SendBufferstr += "--=====" + (Html?"001_Dragon520636771063_":"001_Dragon303406132050_") + "=====--" + enter + enter;
			}
			
			
			
			SendBufferstr += enter + "." + enter;

			if(!Dialog(SendBufferstr,"错误信件信息"))
				return false;


			SendBufferstr = "QUIT" + enter;
			if(!Dialog(SendBufferstr,"断开连接时错误"))
				return false;


			ns.Close();
			tc.Close();
			return true;
		}


		#endregion

		#region
		/*
		/// <summary>
		/// 添加一个密件收件人
		/// </summary>
		/// <param name="str">收件人地址</param>
		public bool AddRecipientBCC(string str)
		{
			if(str==null||str.Trim()=="")
				return true;
			if(RecipientBCCNum<10)
			{
				RecipientBCC.Add(RecipientBCCNum,str);
				RecipientBCCNum++;
				return true;
			}
			else
			{
				errmsg+="收件人过多";
				return false;
			}
		}


		/// <summary>
		/// 添加一组密件收件人(不超过10个),参数为字符串数组
		/// </summary>	
		/// <param name="str">保存有收件人地址的字符串数组(不超过10个)</param>
		public bool AddRecipientBCC(string[] str)
		{
			for(int i=0;i<str.Length;i++)
			{
				if(!AddRecipientBCC(str[i]))
				{
					return false;
				}
			}
			return true;
		}

		*/			
		#endregion	

		#region ISmtpMail 成员
//
		public string MailDomainPort
		{
			get
			{
				// TODO:  添加 SmtpMail.MainDomainPort getter 实现
				return null;
			}
			set
			{
				// TODO:  添加 SmtpMail.MainDomainPort setter 实现
			}
		}
//
//		string Discuz.Common.ISmtpMail.Priority
//		{
//			get
//			{
//				// TODO:  添加 SmtpMail.Discuz.Common.ISmtpMail.Priority getter 实现
//				return null;
//			}
//			set
//			{
//				// TODO:  添加 SmtpMail.Discuz.Common.ISmtpMail.Priority setter 实现
//			}
//		}
//
//		public string MainDomain
//		{
//			get
//			{
//				// TODO:  添加 SmtpMail.MainDomain getter 实现
//				return null;
//			}
//			set
//			{
//				// TODO:  添加 SmtpMail.MainDomain setter 实现
//			}
//		}
//
//		string Discuz.Common.ISmtpMail.MailServerUserName
//		{
//			get
//			{
//				// TODO:  添加 SmtpMail.Discuz.Common.ISmtpMail.MailServerUserName getter 实现
//				return null;
//			}
//			set
//			{
//				// TODO:  添加 SmtpMail.Discuz.Common.ISmtpMail.MailServerUserName setter 实现
//			}
//		}
//
//		string Discuz.Common.ISmtpMail.MailServerPassWord
//		{
//			get
//			{
//				// TODO:  添加 SmtpMail.Discuz.Common.ISmtpMail.MailServerPassWord getter 实现
//				return null;
//			}
//			set
//			{
//				// TODO:  添加 SmtpMail.Discuz.Common.ISmtpMail.MailServerPassWord setter 实现
//			}
//		}
//
		#endregion
	}
	#endregion

}

 

===========================================================

Ftp类

 

当前路径：/CodeFile/dnt26/Discuz.Common/FTP.cs.html
using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections;

namespace Discuz.Common
{
    /// <summary>
    /// FTP类
    /// </summary>
    public class FTP
    {
        #region 变量声明

        /// <summary>
        /// 服务器连接地址
        /// </summary>
        public string server;

        /// <summary>
        /// 登陆帐号
        /// </summary>
        public string user;

        /// <summary>
        /// 登陆口令
        /// </summary>
        public string pass;

        /// <summary>
        /// 端口号
        /// </summary>
        public int port;

        /// <summary>
        /// 无响应时间（FTP在指定时间内无响应）
        /// </summary>
        public int timeout;

        /// <summary>
        /// 服务器错误状态信息
        /// </summary>
        public string errormessage;

   
        /// <summary>
        /// 服务器状态返回信息
        /// </summary>
        private string messages; 

        /// <summary>
        /// 服务器的响应信息
        /// </summary>
        private string responseStr; 

        /// <summary>
        /// 链接模式（主动或被动，默认为被动）
        /// </summary>
        private bool passive_mode;		

        /// <summary>
        /// 上传或下载信息字节数
        /// </summary>
        private long bytes_total; 

        /// <summary>
        /// 上传或下载的文件大小
        /// </summary>
        private long file_size; 

        /// <summary>
        /// 主套接字
        /// </summary>
        private Socket main_sock;

        /// <summary>
        /// 要链接的网络地址终结点
        /// </summary>
        private IPEndPoint main_ipEndPoint;

        /// <summary>
        /// 侦听套接字
        /// </summary>
        private Socket listening_sock;

        /// <summary>
        /// 数据套接字
        /// </summary>
        private Socket data_sock;

        /// <summary>
        /// 要链接的网络数据地址终结点
        /// </summary>
        private IPEndPoint data_ipEndPoint;

        /// <summary>
        /// 用于上传或下载的文件流对象
        /// </summary>
        private FileStream file;

        /// <summary>
        /// 与FTP服务器交互的状态值
        /// </summary>
        private int response;

        /// <summary>
        /// 读取并保存当前命令执行后从FTP服务器端返回的数据信息
        /// </summary>
        private string bucket;

        #endregion

        #region 构造函数

        /// <summary>
        /// 构造函数
        /// </summary>
        public FTP()
        {
            server = null;
            user = null;
            pass = null;
            port = 21;
            passive_mode = true;		
            main_sock = null;
            main_ipEndPoint = null;
            listening_sock = null;
            data_sock = null;
            data_ipEndPoint = null;
            file = null;
            bucket = "";
            bytes_total = 0;
            timeout = 10000;	//无响应时间为10秒
            messages = "";
            errormessage = "";
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="server">服务器IP或名称</param>
        /// <param name="user">登陆帐号</param>
        /// <param name="pass">登陆口令</param>
        public FTP(string server, string user, string pass)
        {
            this.server = server;
            this.user = user;
            this.pass = pass;
            port = 21;
            passive_mode = true;	
            main_sock = null;
            main_ipEndPoint = null;
            listening_sock = null;
            data_sock = null;
            data_ipEndPoint = null;
            file = null;
            bucket = "";
            bytes_total = 0;
            timeout = 10000;	//无响应时间为10秒
            messages = "";
            errormessage = "";
        }
      
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="server">服务器IP或名称</param>
        /// <param name="port">端口号</param>
        /// <param name="user">登陆帐号</param>
        /// <param name="pass">登陆口令</param>
        public FTP(string server, int port, string user, string pass)
        {
            this.server = server;
            this.user = user;
            this.pass = pass;
            this.port = port;
            passive_mode = true;	
            main_sock = null;
            main_ipEndPoint = null;
            listening_sock = null;
            data_sock = null;
            data_ipEndPoint = null;
            file = null;
            bucket = "";
            bytes_total = 0;
            timeout = 10000;	//无响应时间为10秒
            messages = "";
            errormessage = "";
        }


        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="server">服务器IP或名称</param>
        /// <param name="port">端口号</param>
        /// <param name="user">登陆帐号</param>
        /// <param name="pass">登陆口令</param>
        /// <param name="mode">链接方式</param>
        public FTP(string server, int port, string user, string pass, int mode)
        {
            this.server = server;
            this.user = user;
            this.pass = pass;
            this.port = port;
            passive_mode = mode <= 1 ? true : false;
            main_sock = null;
            main_ipEndPoint = null;
            listening_sock = null;
            data_sock = null;
            data_ipEndPoint = null;
            file = null;
            bucket = "";
            bytes_total = 0;
            this.timeout = 10000;	//无响应时间为10秒
            messages = "";
            errormessage = "";
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="server">服务器IP或名称</param>
        /// <param name="port">端口号</param>
        /// <param name="user">登陆帐号</param>
        /// <param name="pass">登陆口令</param>
        /// <param name="mode">链接方式</param>
        /// <param name="timeout">无响应时间(限时),单位:秒 (小于或等于0为不受时间限制)</param>
        public FTP(string server, int port, string user, string pass, int mode, int timeout_sec)
        {
            this.server = server;
            this.user = user;
            this.pass = pass;
            this.port = port;
            passive_mode = mode <= 1 ? true : false;
            main_sock = null;
            main_ipEndPoint = null;
            listening_sock = null;
            data_sock = null;
            data_ipEndPoint = null;
            file = null;
            bucket = "";
            bytes_total = 0;
            this.timeout = (timeout_sec <= 0) ? int.MaxValue : (timeout_sec * 1000);	//无响应时间
            messages = "";
            errormessage = "";
        }

        #endregion

        #region 属性
        /// <summary>
        /// 当前是否已连接
        /// </summary>
        public bool IsConnected
        {
            get
            {
                if (main_sock != null)
                    return main_sock.Connected;
                return false;
            }
        }

        /// <summary>
        /// 当message缓冲区有数据则返回
        /// </summary>
        public bool MessagesAvailable
        {
            get
            {
                if (messages.Length > 0)
                    return true;
                return false;
            }
        }

        /// <summary>
        /// 获取服务器状态返回信息, 并清空messages变量
        /// </summary>
        public string Messages
        {
            get
            {
                string tmp = messages;
                messages = "";
                return tmp;
            }
        }
        /// <summary>
        /// 最新指令发出后服务器的响应
        /// </summary>
        public string ResponseString
        {
            get
            {
                return responseStr;
            }
        }


        /// <summary>
        ///在一次传输中,发送或接收的字节数
        /// </summary>
        public long BytesTotal
        {
            get
            {
                return bytes_total;
            }
        }

        /// <summary>
        ///被下载或上传的文件大小,当文件大小无效时为0
        /// </summary>
        public long FileSize
        {
            get
            {
                return file_size;
            }
        }

        /// <summary>
        /// 链接模式: 
        /// true 被动模式 [默认]
        /// false: 主动模式
        /// </summary>
        public bool PassiveMode
        {
            get
            {
                return passive_mode;
            }
            set
            {
                passive_mode = value;
            }
        }

        #endregion

        #region 操作

        /// <summary>
        /// 操作失败
        /// </summary>
        private void Fail()
        {
            Disconnect();
            errormessage += responseStr;
            //throw new Exception(responseStr);
        }


        private void SetBinaryMode(bool mode)
        {
            if (mode)
                SendCommand("TYPE I");
            else
                SendCommand("TYPE A");

            ReadResponse();
            if (response != 200)
                Fail();
        }


        private void SendCommand(string command)
        {
            Byte[] cmd = Encoding.ASCII.GetBytes((command + "\r\n").ToCharArray());

            if (command.Length > 3 && command.Substring(0, 4) == "PASS")
            {
                messages = "\rPASS xxx";
            }
            else
            {
                messages = "\r" + command;
            }

            try
            {
                main_sock.Send(cmd, cmd.Length, 0);
            }
            catch (Exception ex)
            {
                try
                {
                    Disconnect();
                    errormessage += ex.Message;
                    return;
                }
                catch
                {
                    main_sock.Close();
                    file.Close();
                    main_sock = null;
                    main_ipEndPoint = null;
                    file = null;
                }
            }
        }


        private void FillBucket()
        {
            Byte[] bytes = new Byte[512];
            long bytesgot;
            int msecs_passed = 0;

            while (main_sock.Available < 1)
            {
                System.Threading.Thread.Sleep(50);
                msecs_passed += 50;
                //当等待时间到,则断开链接
                if (msecs_passed > timeout)
                {
                    Disconnect();
                    errormessage += "Timed out waiting on server to respond.";
                    return;
                }
            }

            while (main_sock.Available > 0)
            {
                bytesgot = main_sock.Receive(bytes, 512, 0);
                bucket += Encoding.ASCII.GetString(bytes, 0, (int)bytesgot);
                System.Threading.Thread.Sleep(50);
            }
        }


        private string GetLineFromBucket()
        {
            int i;
            string buf = "";

            if ((i = bucket.IndexOf('\n')) < 0)
            {
                while (i < 0)
                {
                    FillBucket();
                    i = bucket.IndexOf('\n');
                }
            }

            buf = bucket.Substring(0, i);
            bucket = bucket.Substring(i + 1);

            return buf;
        }


        /// <summary>
        /// 返回服务器端返回信息
        /// </summary>
        private void ReadResponse()
        {
            string buf;
            messages = "";

            while (true)
            {
                buf = GetLineFromBucket();

                if (Regex.Match(buf, "^[0-9]+ ").Success)
                {
                    responseStr = buf;
                    response = int.Parse(buf.Substring(0, 3));
                    break;
                }
                else
                    messages += Regex.Replace(buf, "^[0-9]+-", "") + "\n";
            }
        }


        /// <summary>
        /// 打开数据套接字
        /// </summary>
        private void OpenDataSocket()
        {
            if (passive_mode)
            {
                string[] pasv;
                string server;
                int port;

                Connect();
                SendCommand("PASV");
                ReadResponse();
                if (response != 227)
                    Fail();

                try
                {
                    int i1, i2;

                    i1 = responseStr.IndexOf('(') + 1;
                    i2 = responseStr.IndexOf(')') - i1;
                    pasv = responseStr.Substring(i1, i2).Split(',');
                }
                catch (Exception)
                {
                    Disconnect();
                    errormessage += "Malformed PASV response: " + responseStr;
                    return ;
                }

                if (pasv.Length < 6)
                {
                    Disconnect();
                    errormessage += "Malformed PASV response: " + responseStr;
                    return ;
                }

                server = String.Format("{0}.{1}.{2}.{3}", pasv[0], pasv[1], pasv[2], pasv[3]);
                port = (int.Parse(pasv[4]) << 8) + int.Parse(pasv[5]);

                try
                {
                    CloseDataSocket();

                    data_sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

#if NET1
			        data_ipEndPoint = new IPEndPoint(Dns.GetHostByName(server).AddressList[0], port);
#else
                    data_ipEndPoint = new IPEndPoint(System.Net.Dns.GetHostEntry(server).AddressList[0], port);
#endif

                    data_sock.Connect(data_ipEndPoint);

                }
                catch (Exception ex)
                {
                    errormessage += "Failed to connect for data transfer: " + ex.Message;
                    return ;
                }
            }
            else
            {
                Connect();

                try
                {
                    CloseDataSocket();

                    listening_sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                    // 对于端口,则发送IP地址.下面则提取相应信息
                    string sLocAddr = main_sock.LocalEndPoint.ToString();
                    int ix = sLocAddr.IndexOf(':');
                    if (ix < 0)
                    {
                        errormessage += "Failed to parse the local address: " + sLocAddr;
                        return;
                    }
                    string sIPAddr = sLocAddr.Substring(0, ix);
                    // 系统自动绑定一个端口号(设置 port = 0)
                    System.Net.IPEndPoint localEP = new IPEndPoint(IPAddress.Parse(sIPAddr), 0);

                    listening_sock.Bind(localEP);
                    sLocAddr = listening_sock.LocalEndPoint.ToString();
                    ix = sLocAddr.IndexOf(':');
                    if (ix < 0)
                    {
                        errormessage += "Failed to parse the local address: " + sLocAddr;

                    }
                    int nPort = int.Parse(sLocAddr.Substring(ix + 1));

                    // 开始侦听链接请求
                    listening_sock.Listen(1);
                    string sPortCmd = string.Format("PORT {0},{1},{2}",
                                                    sIPAddr.Replace('.', ','),
                                                    nPort / 256, nPort % 256);
                    SendCommand(sPortCmd);
                    ReadResponse();
                    if (response != 200)
                        Fail();
                }
                catch (Exception ex)
                {
                    errormessage += "Failed to connect for data transfer: " + ex.Message;
                    return;
                }
            }
        }


        private void ConnectDataSocket()
        {
            if (data_sock != null)		// 已链接
                return;

            try
            {
                data_sock = listening_sock.Accept();	// Accept is blocking
                listening_sock.Close();
                listening_sock = null;

                if (data_sock == null)
                {
                    throw new Exception("Winsock error: " +
                        Convert.ToString(System.Runtime.InteropServices.Marshal.GetLastWin32Error()));
                }
            }
            catch (Exception ex)
            {
                errormessage += "Failed to connect for data transfer: " + ex.Message;
            }
        }


        private void CloseDataSocket()
        {
            if (data_sock != null)
            {
                if (data_sock.Connected)
                {
                    data_sock.Close();
                }
                data_sock = null;
            }

            data_ipEndPoint = null;
        }

        /// <summary>
        /// 关闭所有链接
        /// </summary>
        public void Disconnect()
        {
            CloseDataSocket();

            if (main_sock != null)
            {
                if (main_sock.Connected)
                {
                    SendCommand("QUIT");
                    main_sock.Close();
                }
                main_sock = null;
            }

            if (file != null)
                file.Close();

            main_ipEndPoint = null;
            file = null;
        }

        /// <summary>
        /// 链接到FTP服务器
        /// </summary>
        /// <param name="server">要链接的IP地址或主机名</param>
        /// <param name="port">端口号</param>
        /// <param name="user">登陆帐号</param>
        /// <param name="pass">登陆口令</param>
        public void Connect(string server, int port, string user, string pass)
        {
            this.server = server;
            this.user = user;
            this.pass = pass;
            this.port = port;

            Connect();
        }

        /// <summary>
        /// 链接到FTP服务器
        /// </summary>
        /// <param name="server">要链接的IP地址或主机名</param>
        /// <param name="user">登陆帐号</param>
        /// <param name="pass">登陆口令</param>
        public void Connect(string server, string user, string pass)
        {
            this.server = server;
            this.user = user;
            this.pass = pass;

            Connect();
        }

        /// <summary>
        /// 链接到FTP服务器
        /// </summary>
        public bool Connect()
        {
            if (server == null)
            {
                errormessage += "No server has been set.\r\n";
            }
            if (user == null)
            {
                errormessage += "No server has been set.\r\n";
            }

            if (main_sock != null)
                if (main_sock.Connected)
                    return true;

            try
            {
                main_sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
#if NET1
			    main_ipEndPoint = new IPEndPoint(Dns.GetHostByName(server).AddressList[0], port);
#else
                main_ipEndPoint = new IPEndPoint(System.Net.Dns.GetHostEntry(server).AddressList[0], port);
#endif

                main_sock.Connect(main_ipEndPoint);
            }
            catch (Exception ex)
            {
                errormessage += ex.Message;
                return false;
            }

            ReadResponse();
            if (response != 220)
                Fail();

            SendCommand("USER " + user);
            ReadResponse();

            switch (response)
            {
                case 331:
                    if (pass == null)
                    {
                        Disconnect();
                        errormessage += "No password has been set.";
                        return false;
                    }
                    SendCommand("PASS " + pass);
                    ReadResponse();
                    if (response != 230)
                    {
                        Fail();
                        return false;
                    }
                    break;
                case 230:
                    break;
            }

            return true;
        }

        /// <summary>
        /// 获取FTP当前(工作)目录下的文件列表
        /// </summary>
        /// <returns>返回文件列表数组</returns>
        public ArrayList List()
        {
            Byte[] bytes = new Byte[512];
            string file_list = "";
            long bytesgot = 0;
            int msecs_passed = 0;
            ArrayList list = new ArrayList();

            Connect();
            OpenDataSocket();
            SendCommand("LIST");
            ReadResponse();

            switch (response)
            {
                case 125:
                case 150:
                    break;
                default:
                    CloseDataSocket();
                    throw new Exception(responseStr);
            }
            ConnectDataSocket();

            while (data_sock.Available < 1)
            {
                System.Threading.Thread.Sleep(50);
                msecs_passed += 50;

                if (msecs_passed > (timeout / 10))
                {
                    break;
                }
            }

            while (data_sock.Available > 0)
            {
                bytesgot = data_sock.Receive(bytes, bytes.Length, 0);
                file_list += Encoding.ASCII.GetString(bytes, 0, (int)bytesgot);
                System.Threading.Thread.Sleep(50);
            }

            CloseDataSocket();

            ReadResponse();
            if (response != 226)
                throw new Exception(responseStr);

            foreach (string f in file_list.Split('\n'))
            {
                if (f.Length > 0 && !Regex.Match(f, "^total").Success)
                    list.Add(f.Substring(0, f.Length - 1));
            }

            return list;
        }

        /// <summary>
        /// 获取到文件名列表
        /// </summary>
        /// <returns>返回文件名列表</returns>
        public ArrayList ListFiles()
        {
            ArrayList list = new ArrayList();

            foreach (string f in List())
            {
                if ((f.Length > 0))
                {
                    if ((f[0] != 'd') && (f.ToUpper().IndexOf("<DIR>") < 0))
                        list.Add(f);
                }
            }

            return list;
        }

        /// <summary>
        /// 获取路径列表
        /// </summary>
        /// <returns>返回路径列表</returns>
        public ArrayList ListDirectories()
        {
            ArrayList list = new ArrayList();

            foreach (string f in List())
            {
                if (f.Length > 0)
                {
                    if ((f[0] == 'd') || (f.ToUpper().IndexOf("<DIR>") >= 0))
                        list.Add(f);
                }
            }

            return list;
        }

        /// <summary>
        /// 获取原始数据信息.
        /// </summary>
        /// <param name="fileName">远程文件名</param>
        /// <returns>返回原始数据信息.</returns>
        public string GetFileDateRaw(string fileName)
        {
            Connect();

            SendCommand("MDTM " + fileName);
            ReadResponse();
            if (response != 213)
            {
                errormessage += responseStr;
                return "";
            }

            return (this.responseStr.Substring(4));
        }

        /// <summary>
        /// 得到文件日期.
        /// </summary>
        /// <param name="fileName">远程文件名</param>
        /// <returns>返回远程文件日期</returns>
        public DateTime GetFileDate(string fileName)
        {
            return ConvertFTPDateToDateTime(GetFileDateRaw(fileName));
        }

        private DateTime ConvertFTPDateToDateTime(string input)
        {
            if (input.Length < 14)
                throw new ArgumentException("Input Value for ConvertFTPDateToDateTime method was too short.");

            //YYYYMMDDhhmmss": 
            int year = Convert.ToInt16(input.Substring(0, 4));
            int month = Convert.ToInt16(input.Substring(4, 2));
            int day = Convert.ToInt16(input.Substring(6, 2));
            int hour = Convert.ToInt16(input.Substring(8, 2));
            int min = Convert.ToInt16(input.Substring(10, 2));
            int sec = Convert.ToInt16(input.Substring(12, 2));

            return new DateTime(year, month, day, hour, min, sec);
        }

        /// <summary>
        /// 获取FTP上的当前(工作)路径
        /// </summary>
        /// <returns>返回FTP上的当前(工作)路径</returns>
        public string GetWorkingDirectory()
        {
            //PWD - 显示工作路径
            Connect();
            SendCommand("PWD");
            ReadResponse();

            if (response != 257)
            {
                errormessage += responseStr;
            }

            string pwd;
            try
            {
                pwd = responseStr.Substring(responseStr.IndexOf("\"", 0) + 1);//5);
                pwd = pwd.Substring(0, pwd.LastIndexOf("\""));
                pwd = pwd.Replace("\"\"", "\""); // 替换带引号的路径信息符号
            }
            catch (Exception ex)
            {
                errormessage += ex.Message;
                return null;
            }

            return pwd;
        }


        /// <summary>
        /// 跳转服务器上的当前(工作)路径
        /// </summary>
        /// <param name="path">要跳转的路径</param>
        public bool ChangeDir(string path)
        {
            Connect();
            SendCommand("CWD " + path);
            ReadResponse();
            if (response != 250)
            {
                errormessage += responseStr;
                return false;
            }
            return true;
        }

        /// <summary>
        /// 创建指定的目录
        /// </summary>
        /// <param name="dir">要创建的目录</param>
        public void MakeDir(string dir)
        {
            Connect();
            SendCommand("MKD " + dir);
            ReadResponse();

            switch (response)
            {
                case 257:
                case 250:
                    break;
                default:
                    {
                        errormessage += responseStr;
                        break;
                    }
            }
        }

        /// <summary>
        /// 移除FTP上的指定目录
        /// </summary>
        /// <param name="dir">要移除的目录</param>
        public void RemoveDir(string dir)
        {
            Connect();
            SendCommand("RMD " + dir);
            ReadResponse();
            if (response != 250)
            {
                errormessage += responseStr;
                return; ;
            }
        }

        /// <summary>
        /// 移除FTP上的指定文件
        /// </summary>
        /// <param name="filename">要移除的文件名称</param>
        public void RemoveFile(string filename)
        {
            Connect();
            SendCommand("DELE " + filename);
            ReadResponse();
            if (response != 250)
            {
                errormessage += responseStr;
            }
        }

        /// <summary>
        /// 重命名FTP上的文件
        /// </summary>
        /// <param name="oldfilename">原文件名</param>
        /// <param name="newfilename">新文件名</param>
        public void RenameFile(string oldfilename, string newfilename)
        {
            Connect();
            SendCommand("RNFR " + oldfilename);
            ReadResponse();
            if (response != 350)
            {
                errormessage += responseStr;
            }
            else
            {
                SendCommand("RNTO " + newfilename);
                ReadResponse();
                if (response != 250)
                {
                    errormessage += responseStr;
                }
            }
        }

        /// <summary>
        /// 获得指定文件的大小(如果FTP支持)
        /// </summary>
        /// <param name="filename">指定的文件</param>
        /// <returns>返回指定文件的大小</returns>
        public long GetFileSize(string filename)
        {
            Connect();
            SendCommand("SIZE " + filename);
            ReadResponse();
            if (response != 213)
            {
                errormessage += responseStr;
            }

            return Int64.Parse(responseStr.Substring(4));
        }

        /// <summary>
        /// 上传指定的文件
        /// </summary>
        /// <param name="filename">要上传的文件</param>
        public bool OpenUpload(string filename)
        {
            return OpenUpload(filename, filename, false);
        }

        /// <summary>
        /// 上传指定的文件
        /// </summary>
        /// <param name="filename">本地文件名</param>
        /// <param name="remotefilename">远程要覆盖的文件名</param>
        public bool OpenUpload(string filename, string remotefilename)
        {
            return OpenUpload(filename, remotefilename, false);
        }

        /// <summary>
        /// 上传指定的文件
        /// </summary>
        /// <param name="filename">本地文件名</param>
        /// <param name="resume">如果存在,则尝试恢复</param>
        public bool OpenUpload(string filename, bool resume)
        {
            return OpenUpload(filename, filename, resume);
        }

        /// <summary>
        /// 上传指定的文件
        /// </summary>
        /// <param name="filename">本地文件名</param>
        /// <param name="remote_filename">远程要覆盖的文件名</param>
        /// <param name="resume">如果存在,则尝试恢复</param>
        public bool OpenUpload(string filename, string remote_filename, bool resume)
        {
            Connect();
            SetBinaryMode(true);
            OpenDataSocket();

            bytes_total = 0;

            try
            {
                file = new FileStream(filename, FileMode.Open);
            }
            catch (Exception ex)
            {
                file = null;
                errormessage += ex.Message;
                return false;
            }

            file_size = file.Length;

            if (resume)
            {
                long size = GetFileSize(remote_filename);
                SendCommand("REST " + size);
                ReadResponse();
                if (response == 350)
                    file.Seek(size, SeekOrigin.Begin);
            }

            SendCommand("STOR " + remote_filename);
            ReadResponse();

            switch (response)
            {
                case 125:
                case 150:
                    break;
                default:
                    file.Close();
                    file = null;
                    errormessage += responseStr;
                    return false;
            }
            ConnectDataSocket();

            return true;
        }

        /// <summary>
        /// 下载指定文件
        /// </summary>
        /// <param name="filename">远程文件名称</param>
        public void OpenDownload(string filename)
        {
            OpenDownload(filename, filename, false);
        }

        /// <summary>
        /// 下载并恢复指定文件
        /// </summary>
        /// <param name="filename">远程文件名称</param>
        /// <param name="resume">如文件存在,则尝试恢复</param>
        public void OpenDownload(string filename, bool resume)
        {
            OpenDownload(filename, filename, resume);
        }

        /// <summary>
        /// 下载指定文件
        /// </summary>
        /// <param name="filename">远程文件名称</param>
        /// <param name="localfilename">本地文件名</param>
        public void OpenDownload(string remote_filename, string localfilename)
        {
            OpenDownload(remote_filename, localfilename, false);
        }

        /// <summary>
        /// 打开并下载文件
        /// </summary>
        /// <param name="remote_filename">远程文件名称</param>
        /// <param name="local_filename">本地文件名</param>
        /// <param name="resume">如果文件存在则恢复</param>
        public void OpenDownload(string remote_filename, string local_filename, bool resume)
        {
            Connect();
            SetBinaryMode(true);

            bytes_total = 0;

            try
            {
                file_size = GetFileSize(remote_filename);
            }
            catch
            {
                file_size = 0;
            }

            if (resume && File.Exists(local_filename))
            {
                try
                {
                    file = new FileStream(local_filename, FileMode.Open);
                }
                catch (Exception ex)
                {
                    file = null;
                    throw new Exception(ex.Message);
                }

                SendCommand("REST " + file.Length);
                ReadResponse();
                if (response != 350)
                    throw new Exception(responseStr);
                file.Seek(file.Length, SeekOrigin.Begin);
                bytes_total = file.Length;
            }
            else
            {
                try
                {
                    file = new FileStream(local_filename, FileMode.Create);
                }
                catch (Exception ex)
                {
                    file = null;
                    throw new Exception(ex.Message);
                }
            }

            OpenDataSocket();
            SendCommand("RETR " + remote_filename);
            ReadResponse();

            switch (response)
            {
                case 125:
                case 150:
                    break;
                default:
                    file.Close();
                    file = null;
                    errormessage += responseStr;
                    return;
            }
            ConnectDataSocket();

            return;
        }

        /// <summary>
        /// 上传文件(循环调用直到上传完毕)
        /// </summary>
        /// <returns>发送的字节数</returns>
        public long DoUpload()
        {
            Byte[] bytes = new Byte[512];
            long bytes_got;

            try
            {
                bytes_got = file.Read(bytes, 0, bytes.Length);
                bytes_total += bytes_got;
                data_sock.Send(bytes, (int)bytes_got, 0);

                if (bytes_got <= 0)
                {
                    //上传完毕或有错误发生
                    file.Close();
                    file = null;

                    CloseDataSocket();
                    ReadResponse();
                    switch (response)
                    {
                        case 226:
                        case 250:
                            break;
                        default: //当上传中断时
                            {
                                errormessage += responseStr;
                                return -1; 
                            }
                    }

                    SetBinaryMode(false);
                }
            }
            catch (Exception ex)
            {
                file.Close();
                file = null;
                CloseDataSocket();
                ReadResponse();
                SetBinaryMode(false);
                //throw ex;
                //当上传中断时
                errormessage += ex.Message;
                return -1;
            }

            return bytes_got;
        }

        /// <summary>
        /// 下载文件(循环调用直到下载完毕)
        /// </summary>
        /// <returns>接收到的字节点</returns>
        public long DoDownload()
        {
            Byte[] bytes = new Byte[512];
            long bytes_got;

            try
            {
                bytes_got = data_sock.Receive(bytes, bytes.Length, 0);

                if (bytes_got <= 0)
                {
                    //下载完毕或有错误发生
                    CloseDataSocket();
                    file.Close();
                    file = null;

                    ReadResponse();
                    switch (response)
                    {
                        case 226:
                        case 250:
                            break;
                        default:
                            {
                                errormessage += responseStr;
                                return -1;
                            }
                    }

                    SetBinaryMode(false);

                    return bytes_got;
                }

                file.Write(bytes, 0, (int)bytes_got);
                bytes_total += bytes_got;
            }
            catch (Exception ex)
            {
                CloseDataSocket();
                file.Close();
                file = null;
                ReadResponse();
                SetBinaryMode(false);
                //throw ex;
                //当下载中断时
                errormessage += ex.Message;
                return -1;
            }

            return bytes_got;
        }

        #endregion
    }
}

 

源码地址

http://www.51aspx.com/CodeFile/dnt26/Discuz.Config/EmailConfigs.cs.html

 

    //http://www.cnblogs.com/zhzhx/archive/2013/05/08/3065973.html
    //http://blog.163.com/china__xuhua/blog/static/199723169201111225136564/
    //http://www.cnblogs.com/MichaelZhangX/archive/2011/08/09/2132094.html

 

socket

--upd client

--tcp client

----stmpclient

----webRequest

----ftpwebRequest