什么是SOCKET
- 1.套接字分类
SOCKET相关概念
- 1.端口
- 2.协议
  - 2.1 TCP：
  - 2.2 UDP
    - 2.1.1 UDP与TCP的区别
      - (1) UDP可靠性不如TCP
      - (2) UDP不能保证有序传输
    - 2.1.2 UDP的优势
Socket一般应用模式：
SOCKET通信基本流程图：
- 服务器端：
- 客户端：
示例程序
- 服务端界面：
- 代码实现如下：

什么是SOCKET

socket的英文原义是“孔”或“插座”。作为进程通信机制，取后一种意思。通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄（其实就是两个程序通信用的）。
socket非常类似于电话插座。以一个电话网为例：电话的通话双方相当于相互通信的2个程序，电话号码就是ip地址。任何用户在通话之前，首先要占有一部电话机，相当于申请一个socket；同时要知道对方的号码，相当于对方有一个固定的socket。然后向对方拨号呼叫，相当于发出连接请求。对方假如在场并空闲，拿起电话话筒，双方就可以正式通话，相当于连接成功。双方通话的过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向socket发送数据和从socket接收数据。通话结束后，一方挂起电话机相当于关闭socket，撤销连接。

1.套接字分类

为了满足不同程序对通信质量和性能的要求，一般的网络系统都提供了以下3种不同类型的套接字，以供用户在设计程序时根据不同需要来选择：
流式套接字（SOCK_STREAM）：提供了一种可靠的、面向连接的双向数据传输服务。实现了数据无差错，无重复的发送，内设流量控制，被传输的数据被看做无记录边界的字节流。在TCP/IP协议簇中，使用TCP实现字节流的传输，当用户要发送大批量数据，或对数据传输的可靠性有较高要求时使用流式套接字。
数据报套接字（SOCK_DGRAM）：提供了一种无连接、不可靠的双向数据传输服务。数据以独立的包形式被发送，并且保留了记录边界，不提供可靠性保证。数据在传输过程中可能会丢失或重复，并且不能保证在接收端数据按发送顺序接收。在TCP/IP协议簇中，使用UDP实现数据报套接字。
原始套接字（SOCK_RAW）：该套接字允许对较低层协议（如IP或ICMP）进行直接访问。一般用于对TCP/IP核心协议的网络编程。

SOCKET相关概念

1.端口

在Internet上有很多这样的主机，这些主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务（应用程序），因此，在网络协议中使用端口号识别主机上不同的进程。
例如：http使用80端口，FTP使用21端口。

2.协议

2.1 TCP：

TCP是一种面向连接的、可靠的，基于字节流的传输层通信协议。为两台主机提供高可靠性的数据通信服务。它可以将源主机的数据无差错地传输到目标主机。当有数据要发送时，对应用进程送来的数据进行分片，以适合于在网络层中传输；当接收到网络层传来的分组时，它要对收到的分组进行确认，还要对丢失的分组设置超时重发等。为此TCP需要增加额外的许多开销，以便在数据传输过程中进行一些必要的控制，确保数据的可靠传输。因此，TCP传输的效率比较低。

2.1.1 TCP的工作过程

TCP是面向连接的协议，TCP协议通过三个报文段完成类似电话呼叫的连接建立过程，这个过程称为三次握手，如图所示：
Socket编程 - 图1

第一次握手：建立连接时，客户端发送SYN包（SEQ=x）到服务器，并进入SYN_SEND状态，等待服务器确认。
第二次握手：服务器收到SYN包，必须确认客户的SYN（ACK=x+1），同时自己也发送一个SYN包（SEQ=y），即SYN+ACK包，此时服务器进入SYN_RECV状态。
第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ACK=y+1)，此包发送完毕，客户端和服务器进入Established状态，完成三次握手。
2.1.2 传输数据
一旦通信双方建立了TCP连接，连接中的任何一方都能向对方发送数据和接收对方发来的数据。TCP协议负责把用户数据（字节流）按一定的格式和长度组成多个数据报进行发送，并在接收到数据报之后按分解顺序重新组装和恢复用户数据。
利用TCP传输数据时，数据是以字节流的形式进行传输的。
2.1.3 连接的终止
建立一个连接需要三次握手，而终止一个连接要经过四次握手，这是由TCP的半关闭（half-close）造成的。具体过程如图所示：

2.1.4 TCP的主要特点
TCP最主要的特点如下。

是面向连接的协议。
端到端的通信。每个TCP连接只能有两个端点，而且只能一对一通信，不能一点对多点直接通信。
高可靠性。通过TCP连接传送的数据，能保证数据无差错、不丢失、不重复地准确到达接收方，并且保证各数据到达的顺序与其发出的顺序相同。
全双工方式传输。
数据以字节流的方式传输。
传输的数据无消息边界。
2.1.5 同步与异步
同步工作方式是指利用TCP编写的程序执行到监听或接收语句时，在未完成工作（侦听到连接请求或收到对方发来的数据）前不再继续往下执行，线程处于阻塞状态，直到该语句完成相应的工作后才继续执行下一条语句。
异步工作方式是指程序执行到监听或接收语句时，不论工作是否完成，都会继续往下执行。
2.2 UDP
UDP是一种简单的、面向数据报的无连接的协议，提供的是不一定可靠的传输服务。所谓“无连接”是指在正式通信前不必与对方先建立连接，不管对方状态如何都直接发送过去。这与发手机短信非常相似，只要知道对方的手机号就可以了，不要考虑对方手机处于什么状态。UDP虽然不能保证数据传输的可靠性，但数据传输的效率较高。
2.1.1 UDP与TCP的区别
(1) UDP可靠性不如TCP
TCP包含了专门的传递保证机制，当数据接收方收到发送方传来的信息时，会自动向发送方发出确认消息；发送方只有在接收到该确认消息之后才继续传送其他信息，否则将一直等待直到收到确认信息为止。与TCP不同，UDP并不提供数据传送的保证机制。如果在从发送方到接收方的传递过程中出现数据报的丢失，协议本身并不能做出任何检测或提示。因此，通常人们把UDP称为不可靠的传输协议。
(2) UDP不能保证有序传输
UDP不能确保数据的发送和接收顺序。对于突发性的数据报，有可能会乱序。
2.1.2 UDP的优势
(1) UDP速度比TCP快
由于UDP不需要先与对方建立连接，也不需要传输确认，因此其数据传输速度比TCP快得多。对于强调传输性能而不是传输完整性的应用（比如网络音频播放、视频点播和网络会议等），使用UDP比较合适，因为它的传输速度快，使通过网络播放的视频音质好、画面清晰。
(2) UDP有消息边界
发送方UDP对应用程序交下来的报文，在添加首部后就向下直接交付给IP层。既不拆分，也不合并，而是保留这些报文的边界。使用UDP不需要考虑消息边界问题，这样使得UDP编程相比TCP，在对接收到的数据的处理方面要方便的多。在程序员看来，UDP套接字使用比TCP简单。UDP的这一特征也说明了它是一种面向报文的传输协议。
(3) UDP可以一对多传输
由于传输数据不建立连接，也就不需要维护连接状态（包括收发状态等），因此一台服务器可以同时向多个客户端传输相同的消息。利用UDP可以使用广播或组播的方式同时向子网上的所有客户进程发送消息，这一点也比TCP方便。
其中，速度快是UDP的首要优势
由于TCP协议中植入了各种安全保障功能，在实际执行的过程中会占用大量的系统开销，无疑使速度受到严重影响。反观UDP，由于抛弃了信息可靠传输机制，将安全和排序等功能移交给上层应用完成，极大地降低了执行时间，使速度得到了保证。简而言之，UDP的“理念”就是“不顾一切，只为更快地发送数据”。

Socket一般应用模式：

SOCKET通信基本流程图：

根据socket通信基本流程图，总结通信的基本步骤：
服务器端：

第一步：创建一个用于监听连接的Socket对像；
第二步：用指定的端口号和服务器的ip建立一个EndPoint对像；
第三步：用socket对像的Bind()方法绑定EndPoint；
第四步：用socket对像的Listen()方法开始监听；
第五步：接收到客户端的连接，用socket对像的Accept()方法创建一个新的用于和客户端进行通信的socket对像;
第六步：通信结束后一定记得关闭socket;

客户端：
第一步：建立一个Socket对像；
第二步：用指定的端口号和服务器的ip建立一个EndPoint对像；
第三步：用socket对像的Connect()方法以上面建立的EndPoint对像做为参数，向服务器发出连接请求；
第四步：如果连接成功，就用socket对像的Send()方法向服务器发送信息；
第五步：用socket对像的Receive()方法接受服务器发来的信息 ;
第六步：通信结束后一定记得关闭socket；
示例程序
服务端界面：

代码实现如下：
```csharp using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; using System.Threading; using System.IO;

namespace SocketServer { public partial class FrmServer : Form { public FrmServer() { InitializeComponent(); }

    //定义回调:解决跨线程访问问题
    private delegate void SetTextValueCallBack(string strValue);
    //定义接收客户端发送消息的回调
    private delegate void ReceiveMsgCallBack(string strReceive);
    //声明回调
    private SetTextValueCallBack setCallBack;
    //声明
    private ReceiveMsgCallBack receiveCallBack;
    //定义回调：给ComboBox控件添加元素
    private delegate void SetCmbCallBack(string strItem);
    //声明
    private SetCmbCallBack setCmbCallBack;
    //定义发送文件的回调
    private delegate void SendFileCallBack(byte[] bf);
    //声明
    private SendFileCallBack sendCallBack;
    //用于通信的Socket
    Socket socketSend;
    //用于监听的SOCKET
    Socket socketWatch;
    //将远程连接的客户端的IP地址和Socket存入集合中
    Dictionary<string, Socket> dicSocket = new Dictionary<string, Socket>();
    //创建监听连接的线程
    Thread AcceptSocketThread;
    //接收客户端发送消息的线程
    Thread threadReceive;
    /// <summary>
    /// 开始监听
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_Start_Click(object sender, EventArgs e)
    {
        //当点击开始监听的时候 在服务器端创建一个负责监听IP地址和端口号的Socket
        socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        //获取ip地址
        IPAddress ip=IPAddress.Parse(this.txt_IP.Text.Trim());
        //创建端口号
        IPEndPoint point=new IPEndPoint(ip,Convert.ToInt32(this.txt_Port.Text.Trim()));
        //绑定IP地址和端口号
        socketWatch.Bind(point);
        this.txt_Log.AppendText("监听成功"+" \r \n");
        //开始监听:设置最大可以同时连接多少个请求
        socketWatch.Listen(10);
        //实例化回调
        setCallBack = new SetTextValueCallBack(SetTextValue);
        receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
        setCmbCallBack = new SetCmbCallBack(AddCmbItem);
        sendCallBack = new SendFileCallBack(SendFile);
        //创建线程
        AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen));
        AcceptSocketThread.IsBackground = true;
        AcceptSocketThread.Start(socketWatch);
    }
    /// <summary>
    /// 等待客户端的连接，并且创建与之通信用的Socket
    /// </summary>
    /// <param name="obj"></param>
    private void StartListen(object obj)
    {
        Socket socketWatch = obj as Socket;
        while (true)
        {               
            //等待客户端的连接，并且创建一个用于通信的Socket
            socketSend = socketWatch.Accept();
            //获取远程主机的ip地址和端口号
            string strIp=socketSend.RemoteEndPoint.ToString();
            dicSocket.Add(strIp, socketSend);
            this.cmb_Socket.Invoke(setCmbCallBack, strIp);
            string strMsg = "远程主机：" + socketSend.RemoteEndPoint + "连接成功";
            //使用回调
            txt_Log.Invoke(setCallBack, strMsg);
            //定义接收客户端消息的线程
            Thread threadReceive = new Thread(new ParameterizedThreadStart(Receive));
            threadReceive.IsBackground = true;
            threadReceive.Start(socketSend);
        }
    }
    /// <summary>
    /// 服务器端不停的接收客户端发送的消息
    /// </summary>
    /// <param name="obj"></param>
    private void Receive(object obj)
    {
        Socket socketSend = obj as Socket;
        while (true)
        {
            //客户端连接成功后，服务器接收客户端发送的消息
            byte[] buffer = new byte[2048];
            //实际接收到的有效字节数
            int count = socketSend.Receive(buffer);
            if (count == 0)//count 表示客户端关闭，要退出循环
            {
                break;
            }
            else
            {
                string str = Encoding.Default.GetString(buffer, 0, count);
                string strReceiveMsg = "接收：" + socketSend.RemoteEndPoint + "发送的消息:" + str;
                txt_Log.Invoke(receiveCallBack, strReceiveMsg);
            }
        }
    }
    /// <summary>
    /// 回调委托需要执行的方法
    /// </summary>
    /// <param name="strValue"></param>
    private void SetTextValue(string strValue)
    {
        this.txt_Log.AppendText(strValue + " \r \n");
    }
    private void ReceiveMsg(string strMsg)
    {
        this.txt_Log.AppendText(strMsg + " \r \n");
    }
    private void AddCmbItem(string strItem)
    {
        this.cmb_Socket.Items.Add(strItem);
    }
    /// <summary>
    /// 服务器给客户端发送消息
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_Send_Click(object sender, EventArgs e)
    {
        try
        {
            string strMsg = this.txt_Msg.Text.Trim();
            byte[] buffer = Encoding.Default.GetBytes(strMsg);
            List<byte> list = new List<byte>();
            list.Add(0);
            list.AddRange(buffer);
            //将泛型集合转换为数组
            byte[] newBuffer = list.ToArray();
            //获得用户选择的IP地址
            string ip = this.cmb_Socket.SelectedItem.ToString();
            dicSocket[ip].Send(newBuffer);
        }
        catch (Exception ex)
        {
            MessageBox.Show("给客户端发送消息出错:"+ex.Message);
        }
        //socketSend.Send(buffer);
    }
    /// <summary>
    /// 选择要发送的文件
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_Select_Click(object sender, EventArgs e)
    {
        OpenFileDialog dia = new OpenFileDialog();
        //设置初始目录
        dia.InitialDirectory = @"";
        dia.Title = "请选择要发送的文件";
        //过滤文件类型
        dia.Filter = "所有文件|*.*";
        dia.ShowDialog();
        //将选择的文件的全路径赋值给文本框
        this.txt_FilePath.Text = dia.FileName;
    }
    /// <summary>
    /// 发送文件
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_SendFile_Click(object sender, EventArgs e)
    {
        List<byte> list = new List<byte>();
        //获取要发送的文件的路径
        string strPath = this.txt_FilePath.Text.Trim();
        using (FileStream sw = new FileStream(strPath,FileMode.Open,FileAccess.Read))
        {
            byte[] buffer = new byte[2048];
            int r = sw.Read(buffer, 0, buffer.Length);
            list.Add(1);
            list.AddRange(buffer);
            byte[] newBuffer = list.ToArray();
            //发送
            //dicSocket[cmb_Socket.SelectedItem.ToString()].Send(newBuffer, 0, r+1, SocketFlags.None);
            btn_SendFile.Invoke(sendCallBack, newBuffer);
        }
    }
    private void SendFile(byte[] sendBuffer)
    {
        try
        {
            dicSocket[cmb_Socket.SelectedItem.ToString()].Send(sendBuffer, SocketFlags.None);
        }
        catch (Exception ex)
        {
            MessageBox.Show("发送文件出错:"+ex.Message);
        }
    }
    private void btn_Shock_Click(object sender, EventArgs e)
    {
        byte[] buffer = new byte[1] { 2};
        dicSocket[cmb_Socket.SelectedItem.ToString()].Send(buffer);
    }
    /// <summary>
    /// 停止监听
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_StopListen_Click(object sender, EventArgs e)
    {
        socketWatch.Close();
        socketSend.Close();
        //终止线程
        AcceptSocketThread.Abort();
        threadReceive.Abort();
    }
}

}

<a name="1br8C"></a>
## 客户端界面
![](https://cdn.nlark.com/yuque/0/2020/png/278385/1589376837288-af801318-b6fb-4500-8599-39e5486460a5.png#align=left&display=inline&height=373&margin=%5Bobject%20Object%5D&originHeight=373&originWidth=541&size=0&status=done&style=shadow&width=541)
<a name="HSMAc"></a>
## 代码实现如下：
```csharp
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.IO;
namespace SocketClient
{
    public partial class FrmClient : Form
    {
        public FrmClient()
        {
            InitializeComponent();
        }
        //定义回调
        private delegate void SetTextCallBack(string strValue);
        //声明
        private SetTextCallBack setCallBack;
        //定义接收服务端发送消息的回调
        private delegate void ReceiveMsgCallBack(string strMsg);
        //声明
        private ReceiveMsgCallBack receiveCallBack;
        //创建连接的Socket
        Socket socketSend;
        //创建接收客户端发送消息的线程
        Thread threadReceive;
        /// <summary>
        /// 连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_Connect_Click(object sender, EventArgs e)
        {
            try
            {
                socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPAddress ip = IPAddress.Parse(this.txt_IP.Text.Trim());
                socketSend.Connect(ip, Convert.ToInt32(this.txt_Port.Text.Trim()));
                //实例化回调
                setCallBack = new SetTextCallBack(SetValue);
                receiveCallBack = new ReceiveMsgCallBack(SetValue);
                this.txt_Log.Invoke(setCallBack, "连接成功");
                //开启一个新的线程不停的接收服务器发送消息的线程
                threadReceive = new Thread(new ThreadStart(Receive));
                //设置为后台线程
                threadReceive.IsBackground = true;
                threadReceive.Start();
            }
            catch (Exception ex)
            {
                MessageBox.Show("连接服务端出错:" + ex.ToString());
            }
        }
        /// <summary>
        /// 接口服务器发送的消息
        /// </summary>
        private void Receive()
        {
            try
            {
                while (true)
                {
                    byte[] buffer = new byte[2048];
                    //实际接收到的字节数
                    int r = socketSend.Receive(buffer);
                    if (r == 0)
                    {
                        break;
                    }
                    else
                    {
                        //判断发送的数据的类型
                        if (buffer[0] == 0)//表示发送的是文字消息
                        {
                            string str = Encoding.Default.GetString(buffer, 1, r - 1);
                            this.txt_Log.Invoke(receiveCallBack, "接收远程服务器:" + socketSend.RemoteEndPoint + "发送的消息:" + str);
                        }
                        //表示发送的是文件
                        if (buffer[0] == 1)
                        {
                            SaveFileDialog sfd = new SaveFileDialog();
                            sfd.InitialDirectory = @"";
                            sfd.Title = "请选择要保存的文件";
                            sfd.Filter = "所有文件|*.*";
                            sfd.ShowDialog(this);
                            string strPath = sfd.FileName;
                            using (FileStream fsWrite = new FileStream(strPath, FileMode.OpenOrCreate, FileAccess.Write))
                            {
                                fsWrite.Write(buffer, 1, r - 1);
                            }
                            MessageBox.Show("保存文件成功");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("接收服务端发送的消息出错:" + ex.ToString());
            }
        }
        private void SetValue(string strValue)
        {
            this.txt_Log.AppendText(strValue + "\r \n");
        }
        /// <summary>
        /// 客户端给服务器发送消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_Send_Click(object sender, EventArgs e)
        {
            try
            {
                string strMsg = this.txt_Msg.Text.Trim();
                byte[] buffer = new byte[2048];
                buffer = Encoding.Default.GetBytes(strMsg);
                int receive = socketSend.Send(buffer);
            }
            catch (Exception ex)
            {
                MessageBox.Show("发送消息出错:" + ex.Message);
            }
        }
        private void FrmClient_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
        }
        /// <summary>
        /// 断开连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btn_CloseConnect_Click(object sender, EventArgs e)
        {
            //关闭socket
            socketSend.Close();
            //终止线程
            threadReceive.Abort();
        }
    }
}

原文地址：https://www.cnblogs.com/dotnet261010/p/6211900.html

Socket编程

什么是SOCKET

1.套接字分类

SOCKET相关概念

1.端口

2.协议

2.1 TCP：

2.1.1 TCP的工作过程

2.1.2 传输数据

2.1.3 连接的终止

2.1.4 TCP的主要特点

2.1.5 同步与异步

2.2 UDP

2.1.1 UDP与TCP的区别

(1) UDP可靠性不如TCP

(2) UDP不能保证有序传输

2.1.2 UDP的优势

(1) UDP速度比TCP快

(2) UDP有消息边界

(3) UDP可以一对多传输

Socket一般应用模式：

SOCKET通信基本流程图：

服务器端：

客户端：

示例程序

服务端界面：

代码实现如下：