首先应该清楚服务端（Server）和客户端（Client）它们各自的功能。
（1）服务端（Server）：
负责接收客户端的请求，然后根据客户端请求的内容不同而给客户端返回相应的数据。
（2）客户端（Client）：
链接服务端，向服务端发送自己的业务需求（也就是数据），然后接受服务端返回过来的信息。
（3）分析服务端和客户端的功能，可以很清楚的知道，它们完成了数据之间的交流，或者说是业务之间的相互传递与获取。
（1）服务器和客户端进行信息传递的通道，socket套接字分为很多种类型，它是一个协议族，常用的协议TCP/IP和UDP两种。
（2）简单来说就是通过socket协议能够进行通信，每种编程语言socket的写法都八九不离十，创建socket通信的步骤都十分接近。
（3）服务端socket和客户端socket通过对方的IP地址和对应应用程序的PORT（端口号）进行连接和数据传输。
（1）首先定义一个Socket套接字对象(这里协议族的类型我们选择TCP协议，TCP传输数据时安全、稳定、可靠，当然对应的性能比UDP差)
Socket socket_server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
（2）不管是客户端还是服务端，创建socket套接字的方式都一样，但是服务端（Server需要绑定该服务端的IP和端口号，以便让客户端进行连接），为了方便这里我绑定的是本地的IP（LocalHost）
IPAddress iPAddress = IPAddress.Parse("127.0.0.1");
int port = 8888;
（3）为服务端绑定IP和端口
socket_server.Bind(new IPEndPoint(iPAddress, port));
(4) 绑定好IP和PORT后就开始监听（将创建的套接字变为监听套接字,以及设置最大同时监听数量）
socket_server.Listen(100);
（5）监听完毕就可以等待客户端的连接了(注意：如果没有客户端连接到来，那么Accept（）方法会一直处于阻塞状态，会 阻塞当前线程，直到有连接到来，线程才会接阻塞，然后将客户端的套接字储存下来，以便接下来的数据传输使用。)
Socket clientSocket = socket_server.Accept();
（6）接受客户端的消息（使用我们上一步储存的客户端套接字来接收）
//这里接受消息的方式是以字节流来接收的，所有用一个byte类型的数组来储存，Receive方法还返回接受直接的实际长度，Encoding.UTF8.GetString()方法将byte类型的数据转化为字符串
byte[] strbyte = new byte[1024]; int count = clientsocket.Receive(strbyte); string ret = Encoding.UTF8.GetString(strbyte,0, count)
（7）向客户端发送消息（发送消息使用Send方法进行）
Console.WriteLine("请输入要发送的消息：");
string str = Console.ReadLine();
byte[] strbyte = Encoding.UTF8.GetBytes(str);
clientsocket.Send(strbyte);
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace SocketServer
{
/// <summary>
/// 服务端
/// </summary>
class Serversocket
{
/// <summary>
/// 服务端入口
/// </summary>
private static Serversocket socketserver;
public static Serversocket Instance()
{
if (socketserver == null)
{
socketserver = new Serversocket();
}
return socketserver;
}
private Socket server;
private IPAddress iPAddress;
private int port;
/// <summary>
/// 初始化数据
/// </summary>
public void Init()
{
iPAddress = IPAddress.Parse("127.0.0.1");
port = 8888;
CreateSocket();
BindAndListen();
WaitClientConnection();
}
/// <summary>
/// 1.创建服务端的套接字
/// </summary>
private void CreateSocket()
{
server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
/// <summary>
/// 2.绑定服务器ip和端口
/// </summary>
private void BindAndListen()
{
server.Bind(new IPEndPoint(iPAddress, port));
server.Listen(100);
}
/// <summary>
/// 用一个列表储存连接成功的客户端
/// </summary>
private List<Socket> ConnectSockeList = new List<Socket>();
/// <summary>
/// 用一个字典储存所有接受客户端消息以及发送给客户端消息的线程
/// </summary>
private Dictionary<int, List<Thread>> recvThreadList = new Dictionary<int, List<Thread>>();
/// <summary>
/// 3.等待客户端的连接
/// </summary>
private void WaitClientConnection()
{
int index = 1;
while (true)
{
Console.WriteLine("当前链接数量："+recvThreadList.Count);
Console.WriteLine("等待客户端的链接：");
Socket ClientSocket = server.Accept();
if (ClientSocket!=null)
{
Console.WriteLine("{0}连接成功！",ClientSocket.RemoteEndPoint);
ConnectSockeList.Add(ClientSocket);
//创建接受客户端消息的线程，并将其启动
Thread recv = new Thread(RecvMessage);
recv.Start(new ArrayList { index, ClientSocket });
Thread send = new Thread(SendMessage);
send.Start(new ArrayList { index, ClientSocket });
recvThreadList.Add(index, new List<Thread> { recv, send });
index++;
}
}
}
/// <summary>
/// 接受客户端的消息
/// </summary>
/// <param name="clientsocket"></param>
private void RecvMessage(object client_socket)
{
ArrayList arraylist = client_socket as ArrayList;
int index = (int)arraylist[0];
Socket clientsocket = arraylist[1] as Socket;
while (true)
{
try
{
byte[] strbyte = new byte[1024];
int count = clientsocket.Receive(strbyte);
string ret = Encoding.UTF8.GetString(strbyte,0, count);
Console.WriteLine("{0}给你发送了消息：{1}",clientsocket.RemoteEndPoint,ret);
}
catch (Exception)
{
//客户端离去时终止线程
Console.WriteLine("代号为:{0}的客户端已经离去！",index);
recvThreadList[index][0].Abort();
}
}
}
/// <summary>
/// 向客户端返回消息
/// </summary>
private void SendMessage(object client_socket)
{
ArrayList arraylist = client_socket as ArrayList;
int index = (int)arraylist[0];
Socket clientsocket = arraylist[1] as Socket;
while (true)
{
try
{
Console.WriteLine("请输入要发送的消息：");
string str = Console.ReadLine();
byte[] strbyte = Encoding.UTF8.GetBytes(str);
clientsocket.Send(strbyte);
}
catch (Exception)
{
Console.WriteLine("代号为：{0}的客户端已经离去！消息发送失败！");
recvThreadList[index][1].Abort();
recvThreadList.Remove(index);
}
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SocketServer
{
class Program
{
static void Main(string[] args)
{
Serversocket.Instance().Init();
Console.ReadKey();
}
}
}
（1）创建一条线程
Thread t1 = new Thread(对应要执行的函数)
//Thread方法有四个重载，常用的三个
public Thread(ThreadStart start);//接受一个无参数的且无返回值的委托
public Thread(ParameterizedThreadStart start);//接受一个带object类型参数的且无返回值的委托
public Thread(ThreadStart start, int maxStackSize);//接受一个无参数的且无返回值的委托,可以指定线程最大堆栈大小
（2）启动一条线程
t1.start()//可以指定object类型的参数
（3）终止一条线程
t1.Abort()
（4）如果不用多线程去处理单个客户端的消息发送和接受，那么当有多个客户端连接时，如果其中一个客户端发生阻塞，那么后面的所有客户端都将阻塞。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
namespace Socket_Client_02
{
/// <summary>
/// 客户端
/// </summary>
class Socket_Client
{
public Socket_Client(string ip,int port)
{
this.iPAddress = IPAddress.Parse(ip);
this.port = port;
}
/// <summary>
/// 套接字
/// </summary>
private Socket client_socket;
/// <summary>
/// 客户端要连接的ip地址
/// </summary>
private IPAddress iPAddress;
/// <summary>
/// 客户端要连接的端口好
/// </summary>
private int port;
/// <summary>
/// 创建客户端连接的套接字
/// </summary>
/// <returns></returns>
public Socket Create_Client_Socket()
{
return new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
}
/// <summary>
/// 连接服务器
/// </summary>
public void Connect_Server()
{
client_socket = Create_Client_Socket();
//tcp连接服务器的时候只需要连接一次，因为tcp是长链接
client_socket.Connect(new IPEndPoint(iPAddress, port));
}
/// <summary>
/// 接收来自服务器的消息
/// </summary>
public void Recv_Msg_By_Client()
{
while (true)
{
byte[] ser_msg = new byte[1024];
int count = client_socket.Receive(ser_msg);
string str_msg = Encoding.UTF8.GetString(ser_msg, 0, count);
if (count > 0)
{
Console.WriteLine("接收到来自{0}的消息为：{1}", client_socket.RemoteEndPoint, str_msg);
}
}
}
/// <summary>
/// 向服务器发送请求
/// </summary>
public void Request_Client()
{
while (true)
{
Console.WriteLine("请输入你要发送到服务器的消息：");
string send_msg = Console.ReadLine();
byte[] by_msg = Encoding.UTF8.GetBytes(send_msg);
client_socket.Send(by_msg);
}
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace Socket_Client_02
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入你要连接的服务器的ip地址：");
string ip = Console.ReadLine();
Console.WriteLine("请输入你要连接的服务器的端口号：");
int port = int.Parse(Console.ReadLine());
//创建套接字
Socket_Client s = new Socket_Client(ip, port);
//连接服务器
s.Connect_Server();
//接收服务器的消息
Thread recv = new Thread(s.Recv_Msg_By_Client);
//给服务器发送消息
Thread send = new Thread(s.Request_Client);
recv.Start();
send.Start();
recv.Join();
send.Join();
Console.ReadKey();
}
}
}
原文：https://www.cnblogs.com/fxw883721/p/13030895.html