第一章发送邮件所需要学习的类
需要引用的命名空间：System.Net.Mail
此命名空间包含了将电子邮件发送到简单邮件的传输协议（SMTP）服务器进行传送的类。该命名空间中的类：
1)MailMessage类：代表的是可以使用SmtpClient类发送的电子邮件,主要用于设置发送电子邮件时，收件人，发件人及邮件内容的一些相关信息。
2)其中SmtpClient类允许应用程序使用简单邮件传输协议（SMTP）来发送电子邮件。
3)总结来说MailMessages是用来设置邮件内容，而SmtpClient是用来实行邮件传输协议（SMTP）的方式MailMessage类的常用属性：通俗易懂理解
AlternateViews ：正文的替代式附件集合
Attachments ：电子邮件的附件集合
Bcc ：密件抄送收件人的地址集合
Body ：邮件正文
Body ：Encoding 邮件正文编码
CC ：电子邮件的发送通知
headers ：电子邮件的标题
IsBodyHtm ：此邮件正文是否为HTML格式
Priority ：电子邮件的优先级
ReplyTo：(已过时) 邮件的回复地址
Sender ：电子邮件发件人地址
Subject ：电子邮件的主题
SubjectEncoding ：电子邮件的主题编码
To ：电子邮件收件人的集合
From ：电子邮箱发件人地址SmtpClient类常用的属性和方法
SmtpClient构造发送电子邮件，必须指定以下内容：
1、用来发送电子邮件的SMTP主机服务器
2、身份验证凭据（如果SMTP服务器要求）
3、发件人的电子邮件地址
4、收件人的电子邮件地址
5、邮件内容属性
Credentials： 验证发件人身份的凭据
DeliveryMethod： 如何处理待发的电子邮件（草稿箱）
Enablessl： 使用安全套接字层(SSL)加密的连接
Host： SMTP事务的主机名或者IP地址
PickupDirectoryLocation： 设置一个文件夹，来保存将由本地SMTP：服务器处理的邮件
Port ：用于SMTP事务的端口
ServicePoint： 传输电子邮件的网络连接
Timeout： 指定的时间量,同时调用Send后发生超时状态。方法
Send(string,string,string,string)：发送电子邮件(SMTP服务器进行传递)参数(发送人,收件人,主题,正文)SendAsync()：发送电子邮件。此方法不会阻止调用线程,Send()方法会阻止其他线程操作(如编写其他的电子邮件信息)
SendAsyncCancel()： 取消异步操作发送电子邮件
UseDefaultCredentials()： 是否发送邮件时，随请求(DefaultCredentials)凭据一起发送。
上面是MailMessages和SmtpClient两个类中重要的属性和方法。
实现邮箱信息传输的代码如下：
/// <summary> /// 发送邮箱 /// </summary> private void SendMail_Click(object sender, EventArgs e) { try { SmtpClient smtp = new SmtpClient(); smtp.Host = @"smtp.qq.com";//邮箱服务器 smtp.EnableSsl = true;//SSL加密 smtp.UseDefaultCredentials = true;//不跟凭据一起发送邮箱 smtp.DeliveryMethod = SmtpDeliveryMethod.Network;//处理待发邮件 smtp.Credentials = new NetworkCredential(@"邮箱地址", @"授权码/密码");//邮件凭据(账户密码) MailMessage mail = new MailMessage(); mail.IsBodyHtml = true;//邮箱内容为Html格式 mail.From = new MailAddress(@"邮箱地址);//发件人邮箱 mail.To.Add(new MailAddress(@"782019024@qq.com"));//收件人邮箱 mail.To.Add(@"邮箱地址");//收件人邮箱 mail.Subject = @"邮箱主题";//邮箱主题 mail.SubjectEncoding = Encoding.UTF8;//邮箱主题编码格式 mail.Body = "邮箱内容";//邮箱正文 mail.BodyEncoding = Encoding.UTF8;//邮箱正文编码 mail.Attachments.Add(new Attachment(@"C:\Users\附件地址.Jpg"));//添加附件文件 for (int i = 1; i < 15; i++) { smtp.Send(mail);//发送邮件 this.MailBody.AppendText("发送成功" + i + "次"); } MessageBox.Show("全部发送成功", "提示窗口", MessageBoxButtons.OK); } catch (Exception ex) { MessageBox.Show(ex.Message.ToString()); } }这里使用的是QQ邮箱的SMTP服务器。
QQ在设置方面：
邮件客户端设置：
接收邮件服务器：imap.qq.com
发送邮件服务器：smtp.qq.com
账户名：您的QQ邮箱账户名（如果您是VIP邮箱，账户名需要填写完整的邮件地址）
密码：您的QQ邮箱密码
电子邮件地址：您的QQ邮箱的完整邮件地址如何设置IMAP服务的SSL加密方式？
使用SSL的通用配置如下：
接收邮件服务器：imap.qq.com，使用SSL，端口号993
发送邮件服务器：smtp.qq.com，使用SSL，端口号465或587
账户名：您的QQ邮箱账户名（如果您是VIP帐号或Foxmail帐号，账户名需要填写完整的邮件地址）
密码：您的QQ邮箱密码
电子邮件地址：您的QQ邮箱的完整邮件地址其中IMAP和POP3两种协议的区别：
1、POP3允许电子邮件客户端下载服务器上的邮件，但是您在电子邮件客户端的操作（如：移动邮件、标记已读等），这是不会反馈到服务器上的。
2、但是IMAP就不同了，电子邮件客户端的操作都会反馈到服务器上，您对邮件进行的操作（如：移动邮件、标记已读等），服务器上的邮件也会做相应的动作。也就是说，IMAP是“双向”的。
3、同时，IMAP可以只下载邮件的主题，只有当您真正需要的时候，才会下载邮件的所有内容。
4、归纳总结：IMAP可以在邮箱客户端中操作邮件，同时会反馈到邮箱服务器，但POP并没有同步邮箱服务器只能在邮箱客户端中进行操作。
目前IMAP暂时还不支持删除文件夹和重命名文件夹的操作（后续版本中会支持）。
第二章Socket网络编程概念
- Socket概念之通信传输流程
1、应用层—应用程序(HTTP/FTP协议)
2、传输层—TCP/UDP,均为传输协议。(UDP不对报文进行检查)
3、网络层—IP地址(v4,v6)
4、链路层(帧)—数据传送基本服务。
流程归纳：应用程序向TCP发送数据信息，之后TCP处理后的结果包在传输到IP层，最后由IP通过网络（帧）将包传送到接收端实体。
应用程序—>TCP—>IP—接收端实体
Socket概念之端口与TCP/UDP（IP）
1、何为端口？端口有什么作用？端口可以用来做什么？
端口在计算机领域中是一个非常重要的概念，为计算机通信而生。端口换言之可以比喻成“计算机中一个”软插槽””。何为端口（软插槽）呢？如果一台计算机中装有各种各样的程序/进程。每个程序都有一个端口（软插槽），那么另外一台远程计算机可以通过（IP：端口）直接实现异地通信。
1.1、端口号常用的分类
公认端口号：由Internet来进行分配一些常用的应用层程序固 定使用的端口。（其中范围：0~1023）
注册端口：是某些登记注册的端口号，这些端口号理论上来讲 只能是授权用户打开的应用软件。（其中范围：1024开始）
一般端口号：随时分配给请求通信的客户进程2、TCP/UDP详解
2.1、UDP和TCP 区别：
UDP和TCP均有校验和，但是在UDP报文中，一般不使用校验和，这样虽然可以加快传输速度但却输在准确性.。而TCP而言每次报文都有进行校验和，确保了每次传输准确性。2.2、(传输层)TCP建立两地通信连接，(网络层)IP负责传输数据：
当应用程序希望通过TCP与另一个应用程序通信时，它会发送一个通信请求，这个请求必须被送一个确切的地址。TCP将在两个应用程序之间建立通信通道，被称此为全双工通信(full-duplex)。
此渠道会维持到某一方关闭为止。归纳来讲TCP负责将数据分割并装入IP包，然后到达IP包的时候重新组合数据，IP最后负责将包发送至接受者。2.3、TCP三次握手确认连接的建立
所谓三次握手建立TCP连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送三个包以确认连接的建立。在Socket编程中，这一过程由客户端执行connect(链接)来触发。
下图说明整个流程：
SYN：同步标志，该标志在建立链接时有效
ACK：确认标志，确认编号栏内包含的确认编号为下一个预期的序列编号，同时提示远端系统已经成功接收所有数据。
Seq：一般用作一堆数字的简化写法。
第一次SYN_SENT(请求链接)握手时：
Client(客户端)将SYN置为1，随机产生seq=J,并将数据包发送给Server，等待Server确认。
第二次SYN_RCVD(接收请求)握手时：
server收到数据包由SYN=1知道Client请求建立链接后，server将SYN和ACK置为1(ack=J+1)，随机产生seq=K，在发送给Client确认请求。
第三次ESTABLISHED(确认请求)握手时：
Client收到server的SYN和ACK包向server发送确认包ACK=1(ack=K+1)，完成整体链接。即可开始传输数据。
2.4、TCP四次挥手
所谓四次挥手即终止TCP链接，就是断开客户端和服务端之间的数据传输。这个过程总共需要发送四个包以确认链接的断开。
在Scoket编程中，这一过程由客户端或者服务端执行close来触发。
FIN_WAIT1:终止等待1
FIN_WAIT2:终止等待2
CLOSE_WAIT:结束等待
LAST_ACK:最后确认
TIME_WAIT:时间等待
第一次握手： Client发送一个FIN M，用来关闭Client对server的数据传送，
第二次握手： server接收到Client请求后并发送ACK = M+1,进行确认。
第三次握手： server再次发送一个FIM N,用来关闭server对Client的数据传送。
第四次握手： Client接收到server的FIN请求后，在此发送ACK=1(ack=K+1)进行确认最后关闭。
第三章 CSharp操作Socket编程精篇（上）
Socket主要有两种类型：
是一种面向连接的Socket，针对于面向连接的TCP服务应用，安全，但是效率低。1.1、流式Socket
是一种面向连接的Socket，针对于面向连接的TCP服务应用，安全，但是效率低。
1.2、数据报式Socket
是一种无连接的Socket，对应无连接的UDP服务应用，不安全，但效率高。Socket一般应用模式（服务端和客户端）
2.1、服务端的Socket（至少需要两个）
01、Socket(第一个)负责接收客户端连接请求(但不负责与客户端通信)。02、当成功接收到客户端的连接便在服务器端产生一个对应的复杂通信的Socket(第二个)
021、在接收到客户端连接时创建。
022、对每个连接成功的客户端，创建对应Socket负责和客户端通信。2.2、客户端的Socket
01、必须指定要连接的服务器地址和端口。
02、通过创建一个Socket对象来初始化一个到服务端的TCP连接。
代码运行图：
更具体的Socket的通讯过程,：
服务端：
01、申请一个socket。
02、绑定一个IP地址和一个端口。
03、开始侦听，等待接收连接。
客户端：
01、申请一个socket。
02、连接服务端（指向IP地址和端口号）
服务端接收到请求后创建一个Socket与客户端建立连接并进行通讯，最后原监听的Socket继续监听。
注意：负责通信的Socket不能无限创建，创建的数量和操作系统有关。
Socket的构造函数与方法及相关的类
3.1、Socket有三种构造函数的方法这里只讲一种：Socket s = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);这个构造函数包含了:
AddressFamily//定义可使用的寻址方案
SocketType//定义Socket的类型
ProtocolType//定义Socket支持的协议注意：
1、端口号必须在1和65535之间，最好在1024以后。
2、连接远程主机必须指定正在监听端口。
例如：IPAddress IP = IPAddress.Parse(192.168.1.1);//IP地址 IPEndPoint IPpoint = new IPEndPoint(IP, 9000);//端口号 Socket serversockst = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//服务端 Socket clientsockst = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//客户端 serversockst.Bind(IPpoint);//绑定一个端口和IP clientsockst.Connect(IPpoint);//指向一个端口和IP服务端和客户端IP和端口号需要一致，才能建立通讯通道。
3、一个Socket一次只能连接一台主机。
4、Socket关闭后无法再次使用。
5、每个Socket对象只能与一台远程主机连接。如果你想连接到多台远程主机，必须创建多个Socket对象。3.2、相关的类与Socket方法
a.相关类：
IPAddress:包含一个IP地址
IPEndPoint:包含一对IP地址和端口b.方法：
同步：
Socket();//创建一个Socket
Bind();//绑定一对本地IP和端口号（IPEndPoint）
Listen();//socket侦听正在传入的连接尝试，并指定队列中最多可容纳的等待接受的传入连接数
Connect();//初始化与另一个Socket的连接（客户端）
Accept();//接收连接并返回一个新的Socket（服务端）
Send();//输出数据到Socket（发送消息）同步
Receive();//从Socket中读取数据（读取消息）
Close();//关闭Socket销毁连接异步：
BeginConnect();//开始一个对远程主机连接的异步请求
EndConnect();//结束挂起的异步连接请求例：SocketClient.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);BeginSend();//发送数据到Socket（发送消息）异步
EndSend();//结束挂起的异步发送例：SocketClient.BeginSend(bytedata,0,bytedata.Length,SocketFlags.None,new AsyncCallback(SendCallback), client);BeginReceive();//接收数据
EndReceive();//结束挂起的异步接收请求例：SocketClient.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);1、其中AsyncCallback异步委托类为相应异步操作完成后，继续调用。AsyncCallback为客户端应用程序提供完成异步操作的方法。开始异步操作时，该回调委托被提供给客户端。
**2、**AsyncCallback引用的事件处理程序包含完成客户端异步任务的程序逻辑。
3、在通信中，AsyncCallback中的封装你要回调的函数，state则是相当于回调函数的参数。（IAsyncResult类型）
c.属性：
RemoteEndPoint;//获取远程的IP 地址和端口
LocalEndPoint;//获取本地的IP地址和端口3.3、Csharp的异步Socket与同步Socket的主要区别：
服务端为B
客户端为A1、
假设（Socket同步的情况下）服务端B和客户端A已经三次握手，建立了链接。
A和B之间已经可以进行通信。假如B端在请求A端的时候请求成功就发送一条数据。那么A端就可以直接拿Socket对象得到他的信息。但是假如B端并没有在连接成功后直接发送信息而是在后来不确定的时间内发送的信息。那么A端就无法得到这条信息。
通常情况下：一个定时器去不断扫描这个数据缓存区。但是效率低下。
所以Socket同步只适合在短时间通讯，不适合长期通讯。2、
那么如何解决这个问题呢?
这里就需要用到我们的异步传输，异步传输的原理：
在A端得到这个Socket对象以后并不是直接去接收数据而是建立一个回调函数，回调函数由系统维护的。
他在指定的时间自动去扫描数据存储区。假如有数据他就把数据存储到指定的字节数组中。总结：
1、短时间一次连接发送数据交互信息的，适合用于同步。
2、长时间连接发送数据交互信息的，适合用于异步。
3、执行过程Socket：3.1解决方法就是通过新建一个线程，让这个线程去监听等待响应，从而将Browser从阻塞中解救出来，去处理其他的事情。按照我个人的理解，同步（阻塞）+多线程就是异步了。因为按照以上的说法，系统维护的回调函数实现的就是我们这里的新建的线程完成的功能。
3.2说白了，同步就是自己去监听等待响应，异步是将监听等待响应的工作交给了其他的线程。
以下程序代码只能作为Socket局域网通信的基础，如何实现互联网通信请继续往下看。
3.3.1、Socket同步代码实现：
1、SocketServer（服务端代码实现）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Net;
using System.Windows.Forms;
using System.Windows;
using System.Threading;
namespace Sockets编程通信
{
class SocketServer
{
private delegate void dele(object o);
private delegate void deleShow(string o);
private dele GoIntercept;//侦听委托
private dele GoMessage;//显示委托
Dictionary<string, Socket> DicSocket = new Dictionary<string, Socket>();//已连接的客户端集合
TextBox SEA = null;
TextBox SShow = null;
TextBox SP = null;
ComboBox SA = null;
ServerANDClient S = null;
/// <summary>
/// Server服务端函数
/// </summary>
/// <param name="ShowErrorAndOut">提示窗口</param>
/// <param name="SocketShow">显示窗口</param>
/// <param name="SocketImPort">输入窗口</param>
/// <param name="SocketAbutment">对接列表</param>
/// <param name="s">主窗体</param>
public SocketServer(TextBox ShowErrorAndOut, TextBox SocketShow, TextBox SocketImPort, ComboBox SocketAbutment,ServerANDClient s)
{
SEA = ShowErrorAndOut;
SShow = SocketShow;
SP = SocketImPort;
SA = SocketAbutment;
S = s;
}
/// <summary>
/// 服务端绑定IP和端口
/// </summary>
/// <param name="IP">本地IPv4</param>
/// <param name="Point">指定端口</param>
public void IPandPoint(string IP,string Point)
{
try
{
IPAddress ip = IPAddress.Parse(IP);
IPEndPoint IPandPont = new IPEndPoint(ip, int.Parse(Point));
Socket Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Server.Bind(IPandPont);//绑定IP和端口
Server.Listen(10);//设置最大待连接的客户端列表
show("Server配置设置成功。");
GoIntercept = new dele(ServerIntercept);//委托
Thread th = new Thread(new ThreadStart(delegate
{
GoIntercept(Server);//侦听客户端对接
}));
th.IsBackground = true;
th.Start();
}
catch (Exception Error) { show(Error.Message.ToString()); }
}
/// <summary>
/// 服务端侦听可连接的对接
/// </summary>
/// <param name="o"></param>
private void ServerIntercept(object o)
{
Socket Server = o as Socket;
try
{
Socket SocketClient = Server.Accept();//对接成功
show("跟客户端对接成功。");
show("本地：" + SocketClient.LocalEndPoint.ToString());
show("远程：" + SocketClient.RemoteEndPoint.ToString());
Thread thh = new Thread(new ThreadStart(delegate
{
S.ReconsitutionMethodLabel();
}));
thh.IsBackground = true;
thh.Start();
string IPandPoint = SocketClient.RemoteEndPoint.ToString();
DicSocket.Add(IPandPoint, SocketClient);//已连接的客户端添加到集合中
show3(IPandPoint);//对接列表赋值
GoMessage = new dele(ServerReceive);
Thread th = new Thread(new ThreadStart(delegate
{
GoMessage(SocketClient);//接收数据
}));
th.IsBackground = true;
th.Start();
}
catch (Exception Error) { show(Error.Message.ToString()); }
}
/// <summary>
/// 服务端接收信息数据
/// </summary>
/// <param name="o"></param>
private void ServerReceive(object o)
{
Socket ServerClient = o as Socket;
try
{
while (true)
{
byte[] buffte = new byte[1024 * 1024];
int sum = ServerClient.Receive(buffte);//对客户端发送过来的数据，保存到缓冲区中。
string lineTo = Encoding.UTF8.GetString(buffte);//输出到显示窗口中。
show2(ServerClient.RemoteEndPoint.ToString() + " " + DateTime.Now.ToString());
show2(lineTo);
show("接收消息成功");
}
}
catch (Exception Error) { show(Error.Message.ToString()); }
}
/// <summary>
/// 发送消息
/// </summary>
public void ServerShow()
{
try
{
byte[] buffte = Encoding.UTF8.GetBytes(SP.Text.ToString());
DicSocket[SA.Text.ToString()].Send(buffte);//发送消息
show("发送消息成功");
show2(DicSocket[SA.Text.ToString()].LocalEndPoint.ToString() + " "+ DateTime.Now.ToString());
show2(SP.Text.ToString());
SP.Text = "";//清空
}
catch (Exception Error) { show(Error.Message.ToString()); }
}
#region 输出
/// <summary>
/// 提示窗口
/// </summary>
/// <param name="text"></param>
private void show(string text)
{
try
{
Thread th = new Thread(new ThreadStart(delegate
{
S.Invoke(new EventHandler(delegate {
SEA.AppendText(text.ToString() + "\r\n");
}));
}));
th.IsBackground = true;
th.Start();
}
catch { }
}
/// <summary>
/// 显示窗口
/// </summary>
/// <param name="text"></param>
private void show2(string text)
{
try
{
Thread th = new Thread(new ThreadStart(delegate
{
S.Invoke(new EventHandler(delegate {
SShow.AppendText("\r\n" + text.ToString());
}));
}));
th.IsBackground = true;
th.Start();
}
catch { }
}
/// <summary>
/// 对接列表的赋值
/// </summary>
/// <param name="text"></param>
private void show3(string text)
{
try
{
Thread th = new Thread(new ThreadStart(delegate
{
S.Invoke(new EventHandler(delegate
{
SA.Text = text;
}));
}));
th.IsBackground = true;
th.Start();
}
catch { }
}
#endregion
}
}2、SocketClient（客户端代码实现）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
namespace Sockets编程通信
{
class SocketClient
{
ServerANDClient S = null;
TextBox SocketShow = null;
TextBox WinDosError = null;
TextBox SocketExport = null;
ComboBox ComSocketClientEndPoint2 = null;
/// <summary>
/// Client客户端函数
/// </summary>
/// <param name="s">主窗体</param>
/// <param name="socketshow">显示窗口</param>
/// <param name="windoserror">提示窗口</param>
/// <param name="socketexport">发送窗口</param>
public SocketClient(ServerANDClient s, TextBox socketshow, TextBox windoserror, TextBox socketexport, ComboBox comsocketclientendpoint2)
{
S = s;
SocketShow = socketshow;
WinDosError = windoserror;
SocketExport = socketexport;
ComSocketClientEndPoint2 = comsocketclientendpoint2;
}
/// <summary>
/// 连接服务端配置
/// </summary>
/// <param name="ip">本地IP地址</param>
/// <param name="point">端口号</param>
public void IPandPoint(string ip,string point)
{
try
{
IPAddress IP = IPAddress.Parse(ip);
IPEndPoint IPendPoint = new IPEndPoint(IP, int.Parse(point));
Socket SocketClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
SocketClient.Connect(IPendPoint);//建立与远程服务端的连接
SocketClientSend = SocketClient;
THComIPEndPoint(SocketClient.RemoteEndPoint.ToString());//获取远程主机IP和端口
THShowError("对接服务端完成");
Thread th = new Thread(new ThreadStart(delegate
{
SocketReceive(SocketClient);
}));
th.IsBackground = true;
th.Start();
}
catch (Exception e) { THShowError(e.Message.ToString()); }
}
Socket SocketClientSend = null;
/// <summary>
/// 客户端接收消息
/// </summary>
private void SocketReceive(object o)
{
Socket SocketClientReceive = o as Socket;
try
{
while (true)
{
byte[] buffet = new byte[1024 * 1024];
int sum = SocketClientReceive.Receive(buffet);//读取Socket数据信息，读取服务端发送的信息
string line = Encoding.UTF8.GetString(buffet, 0, sum);
THShowError("接收消息成功");
THShowMess(SocketClientReceive.RemoteEndPoint + "\t" + DateTime.Now);
THShowMess(line);//输出到显示窗口
}
}
catch (Exception e) { THShowError(e.Message.ToString()); }
}
/// <summary>
/// 客户端发送消息
/// </summary>
public void SocketSend()
{
try
{
SocketClientSend.Send(Encoding.UTF8.GetBytes(SocketExport.Text));
THShowError("发送消息成功");
THShowMess(SocketClientSend.LocalEndPoint.ToString() + "\t" + DateTime.Now);
THShowMess(SocketExport.Text);//显示窗口
SocketExport.Text = "";
}
catch (Exception e) { THShowError(e.Message.ToString()); }
}
#region 输出
/// <summary>
/// 显示窗口
/// </summary>
/// <param name="text"></param>
private void THShowMess(string text)
{
try
{
Thread th = new Thread(new ThreadStart(delegate
{
S.Invoke(new EventHandler(delegate
{
SocketShow.AppendText(text + "\r\n");
}));
}));
th.IsBackground = true;
th.Start();
}
catch (Exception e) { MessageBox.Show(e.Message.ToString()); }
}
/// <summary>
/// 提示窗口
/// </summary>
private void THShowError(string text)
{
try
{
Thread th = new Thread(new ThreadStart(delegate
{
S.Invoke(new EventHandler(delegate {
WinDosError.AppendText(text + "\r\n");
}));
}));
th.IsBackground = true;
th.Start();
}
catch (Exception e) { MessageBox.Show(e.Message.ToString()); }
}
/// <summary>
/// 对接服务端列表IP
/// </summary>
/// <param name="text"></param>
private void THComIPEndPoint(string text)
{
try
{
Thread th = new Thread(new ThreadStart(delegate
{
S.Invoke(new EventHandler(delegate
{
ComSocketClientEndPoint2.Text = text;
}));
}));
th.IsBackground = true;
th.Start();
}
catch (Exception ex) { MessageBox.Show(ex.Message.ToString()); }
}
}- 3.3.2、Socket异步代码实现：
1、SocketClient（客户端代码实现）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using System.Windows;
using System.Windows.Forms;
using System.Collections;
namespace Socket异步通讯
{
/// <summary>
/// 客户端Socket
/// </summary>
public class Client
{
#region 设备信号
//来自远程设备的响应
public static String response = String.Empty;
//服务端列表
static Dictionary<string, Socket> dic = new Dictionary<string, Socket>();
//
static string Point = "";
#endregion
static Form1 F = null;
public Client(Form1 f)
{
F = f;
}
#region 异步连接
/// <summary>
/// 连接远程服务器发送请求
/// </summary>
/// <param name="remoteIP">IP</param>
/// <param name="port">端口</param>
public static void StartClient(string remoteIP,int port)
{
try
{
//为套接字建立远程端点。
IPAddress ipAddress = IPAddress.Parse(remoteIP);
IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);
//创建TCP/IP套接字。
Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//连接到远程端点
client.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), client);
dic.Add(client.RemoteEndPoint.ToString(), client);
Point = client.RemoteEndPoint.ToString();
}
catch (Exception e)
{
MessageBox.Show(e.Message.ToString());
}
}
/// <summary>
/// 连接远程主机
/// </summary>
/// <param name="ar"></param>
private static void ConnectCallback(IAsyncResult ar)
{
try
{
// 从状态对象检索套接字。
Socket client = (Socket)ar.AsyncState;
//完成连接
client.EndConnect(ar);
//接收消息
Receive(client);
}
catch (Exception ex) { MessageBox.Show(ex.Message.ToString()); }
}
#endregion
#region 异步接收消息
/// <summary>
/// 异步读取消息
/// </summary>
/// <param name="client"></param>
private static void Receive(Socket client)
{
try
{
while (true)
{
//创建状态对象
StateObject state = new StateObject();
state.workSocket = client;
//开始服务端设备接收数据。
state.workSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);
}
}
catch (Exception e) { MessageBox.Show(e.Message.ToString()); }
}
/// <summary>
/// 异步读取消息确认
/// </summary>
/// <param name="ar"></param>
private static void ReceiveCallback(IAsyncResult ar)
{
try
{
//检索状态对象和客户端套接字
//来自异步状态对象。
StateObject state = (StateObject)ar.AsyncState;
Socket client = state.workSocket;
//接收服务端消息
int bytesRead = client.EndReceive(ar);
//每次接收到数据时
if (bytesRead > 0)
{
//可能有更多的数据，所以存储收到的数据到目前为止。
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
//获取其余的数据。
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);
}
Thread th = new Thread(new ThreadStart(delegate
{
F.Invoke(new EventHandler(delegate
{
F.Receive(state.sb.ToString());
}));
}));
th.IsBackground = true;
th.Start();
}
catch (Exception ex) { MessageBox.Show(ex.Message.ToString()); }
}
#endregion
#region 异步发送消息
/// <summary>
/// 异步发送消息
/// </summary>
/// <param name="client">客户端Socket</param>
/// <param name="data">数据信息</param>
public static void Send(string data)
{
try
{
StateObject so = new StateObject();
so.workSocket = dic[Point] as Socket;
//使用ASCII编码将字符串数据转换为字节数据。
byte[] bytedata = Encoding.ASCII.GetBytes(data);
//开始将数据发送到服务端。
so.workSocket.BeginSend(bytedata, 0, bytedata.Length, SocketFlags.None, new AsyncCallback(SendCallback), so.workSocket);
}
catch (Exception e) { MessageBox.Show(e.Message.ToString()); }
}
/// <summary>
/// 异步发送消息成功确认
/// </summary>
/// <param name="ar">异步状态</param>
private static void SendCallback(IAsyncResult ar)
{
//从状态对象检索套接字。
Socket client = (Socket)ar.AsyncState;//异步开始
//将数据完全发送到远程设备。
//如果发送成功，返回发送的字节数，否则返回无效
client.EndSend(ar);
Thread th = new Thread(new ThreadStart(delegate
{
F.Invoke(new EventHandler(delegate
{
F.Receive("");
}));
}));
th.IsBackground = true;
th.Start();
}
#endregion
/// <summary>
/// 释放客户端
/// </summary>
public static void Release()
{
dic[Point].Shutdown(SocketShutdown.Both);
dic[Point].Close(100);
}
}2、SocketServer（服务端代码实现）
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using System.Windows.Forms;
using System.Collections;
namespace Socket异步通讯
{
class Server
{
/// <summary>
/// 存储客户IP和端口的列表
/// </summary>
static Dictionary<string, Socket> dic = new Dictionary<string, Socket>();
/// <summary>
/// 客户端IP和端口
/// </summary>
static string Point = "";
static Form1 F = null;
public Server(Form1 f)
{
F = f;
}
/// <summary>
/// 监听客户端请求列表
/// </summary>
/// <param name="IP"></param>
/// <param name="port"></param>
public static void StartListening(string IP,int port)
{
IPAddress ipaddress = IPAddress.Parse(IP);
IPEndPoint IPEndPoint = new IPEndPoint(ipaddress,port);
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
server.Bind(IPEndPoint);
server.Listen(10);
//启动异步套接字监听连接。
server.BeginAccept(new AsyncCallback(Accept), server);
}
catch (Exception e)
{
MessageBox.Show(e.Message.ToString());
}
}
/// <summary>
/// 连接客户端
/// </summary>
/// <param name="ar"></param>
public static void Accept(IAsyncResult ar)
{
try
{
//发送等待线程可以继续进行的信号。并释放所有等待线程
//连接客户端成功
Socket server = (Socket)ar.AsyncState;
Socket serverClient = server.EndAccept(ar);
//储存客户端列表
dic.Add(serverClient.RemoteEndPoint.ToString(), serverClient);
//客户端远程IP和端口
Point = serverClient.RemoteEndPoint.ToString();
while (true)
{
//连接成功后接收消息
StateObject state = new StateObject();
state.workSocket = serverClient;
//异步接收消息
serverClient.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveIAsyncResult), state);
}
}
catch (Exception e) { MessageBox.Show(e.Message.ToString()); }
}
/// <summary>
/// 接收客户端信息
/// </summary>
/// <param name="ar"></param>
public static void ReceiveIAsyncResult(IAsyncResult ar)
{
try
{
StateObject state = (StateObject)ar.AsyncState;
Socket serverReceive = state.workSocket;
//读取数据返回数据中的字节数
int bytesRead = serverReceive.EndReceive(ar);
//判断数据是否读取完毕
if (bytesRead > 0)
{
//接收字符串
state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, StateObject.BufferSize));
}
Thread th = new Thread(new ThreadStart(delegate
{
F.Invoke(new EventHandler(delegate
{
F.Receive(state.sb.ToString());
}));
}));
th.IsBackground = true;
th.Start();
}
catch (Exception ex) { MessageBox.Show(ex.Message.ToString()); }
}
/// <summary>
/// 给客户端发送消息
/// </summary>
public static void Send(string data)
{
try
{
byte[] by = Encoding.UTF8.GetBytes(data);
dic[Point].BeginSend(by, 0, by.Length, SocketFlags.None, new AsyncCallback(SendIAsyncResult), dic[Point]);
}
catch (Exception e) { MessageBox.Show(e.Message.ToString()); }
}
/// <summary>
/// 发送消息确认
/// </summary>
/// <param name="ar"></param>
public static void SendIAsyncResult(IAsyncResult ar)
{
try
{
Socket serverSend = (Socket)ar.AsyncState;
serverSend.EndSend(ar);
Thread th = new Thread(new ThreadStart(delegate
{
F.Invoke(new EventHandler(delegate
{
F.Receive("");
}));
}));
th.IsBackground = true;
th.Start();
}
catch (Exception ex) { MessageBox.Show(ex.Message.ToString()); }
}
}
}Socket如何在广域网上通信？
4.1使用端口映射，什么是端口映射呢？
NAT（网络地址转换）
1、端口映射是NAT的一种，功能是把公网的地址翻译成私有地址。
2、端口映射是将一台或者多台内网主机，映射到公网IP地址，当用户访问映射端口中的某一个端口时，服务器(路由器)会将请求转移到本地局域网中某个匹配的端口主机。3、端口映射专业解析：端口指定的是软件形式上的端口，不是I/O硬件进出端口，服务器可以向外提供多种服务，比如一台服务器可以有FTP，WEB软件服务，比如WEB端口80，FTP端口21。这样通过不同的端口，可以互相不干扰的情况下通信。
4、分类：
动态端口映射：（这里参照TCP/IP三次握手）（前提是对方服务器有对这个网页端口做出映射，内机才能进行访问。）4.1)、当内网中的一台电脑访问网页时，会发送一个NAT网关数据包，其中包含网页的IP和端口，本机私有IP和端口。
4.2)、 NAT网关会把本机私有IP和端口转换成公网IP和端口，并且记住这个链接服务状态。
4.3)、最后实现了通讯渠道，内网发送数据给网页，网页会根据数据做出反应。传输数据给内网主机。静态端口映射：
NAT网关有一个固定端口，设顶此端口收到数据转发到内机中的某个IP和端口，这个固定端口永远存在的。相当访问内机的一道门，外网可以随时主动访问内网的这台内机。
Socket套接字通讯思路：
外网通过公网IP和服务端口，访问到我的路由服务器，然后通过路由服务器找到内网的本地IP主机中的软件端口。
注：但是在建立连接的前提下，必须是运营商有授权给你访问内网的权限。通过对比WAN口状态和公网IP是否一致即可得出结果。
如图：
1、如果在这中情况就需要采用反向代理去解决这个映射问题，进行内网穿透。
2、比如我使用花生壳，当一个代理服务器能够代理外部网络上的主机，访问内部网络时，这种代理服务的方式称为反向代理服务。
3、此时代理服务器对外就表现为一个Web服务器，外部网络就可以简单把它当作一个标准的Web服务器而不需要特定的配置。
设置步骤：
1、设置映射
2、设置DMZ主机
3、设置花生壳账号，在这之前去下载花生壳软件，注册账号。
4.2端口映射常见问题总结
1、首先检查您设置的端口影射是否正确映射到您内网的服务器。即您设置的转发规则的IP地址是否为您服务器的IP地址。2、无法访问内网的服务器，请检查服务器是否开启了。您可以在局域网内使用其他的计算机访问一下您的服务器，确认服务器是否开启，并能成功访问。
3、请您检查您是否映射了服务器所需的所有端口，有可能没有完全设置访问服务器所需的端口，导致访问失败。您可以通过开启“DMZ主机”来检测一下，是否端口没有映射完全。若开启DMZ主机后，能正常访问服务器，则可能是端口添加不完全。
4、路由器上是否设置了“防火墙”，是否将服务器通信的端口过滤，导致访问失败。
5、本机防火墙：因本地网络为信任区域，防火墙并不会阻止本地网络的访问，若访问源地址为外网地址（非信任区域地址），则可能会被防火墙拦截而无法访问；
6、服务商将相应端口屏蔽：在路由器WAN口接一台电脑模拟内外网环境，若WAN口所接电脑可以正常访问内网服务器，但在Internet上无法访问，则可能是服务器将相应端口屏蔽导致虚拟服务器无法访问；
注：
1、若是80端口的WEB服务器，一定要注意路由器的远端WEB管理端口是否更改，否则两者会冲突；2、检查虚拟服务器是否映射成功一定要从外网进行访问，不要从内网用WAN口IP去访问，这样在测试的时候是成功的，但实际外网并不能成功访问。
3、特殊的服务器，如网络摄像机及特殊的应用软件等，如果客户自己都不清楚通讯的端口，可先尝试DMZ主机以确认是否可以使用，同时建议客户咨询软件提供商。