使用Socket建立网络连接TCP版

来源：互联网发布：sqlserver 行为日志编辑：程序博客网时间：2024/05/21 09:17

TCPServer:

using System;

using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
using System.Collections.Generic;
using System.Net.NetworkInformation;

namespace TcpServer
{
class Program
{
static void Main(string[] args)
{
Server server = new Server();
server.StartUp();

while (true)
{
string str = Console.ReadLine();
server.SendAll(str);
}
}
}

public class Server
{
//配置相关
private string _ip = "192.168.30.35";
private int _port = 10000;
//服务器套接字
private Socket _server;
//接受客户端连接的线程，因为Accept是一个阻塞线程的方法，而且此方法还需要循环执行
private Thread _acceptClientConnectThread;
//所有已经连接的客户端
private List<Socket> _clientList = new List<Socket>();

/// <summary>
/// 启动服务器 = 建立流式套接字 + 配置本地地址
/// </summary>
public void StartUp()
{
try
{
//建立套接字，寻址方案，套接字类型，协议类型
_server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//_server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

//配置本地地址
EndPoint endPoint = new IPEndPoint(GetIpv4(NetworkInterfaceType.Ethernet), _port);
_server.Bind(endPoint);
//监听和接受客户端请求
_server.Listen(30);
//开启一个接受连接的线程
_acceptClientConnectThread = new Thread(AcceptClientConnect);
_acceptClientConnectThread.Start();

Console.WriteLine("{0}:{1} StartUp...", _ip, _port);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}

/// <summary>
/// 接受客户端连接
/// </summary>
public void AcceptClientConnect()
{
while (true)
{
try
{
//接受客户端连接
Socket clientSocket = _server.Accept();
//维护一个客户端在线列表
_clientList.Add(clientSocket);

//获取客户端的网络地址标识
IPEndPoint clientEndPoint = clientSocket.RemoteEndPoint as IPEndPoint;
//输出一下地址和端口
Console.WriteLine("{0}：{1} Connect...", clientEndPoint.Address.ToString(), clientEndPoint.Port);

//接受客户端消息的线程
Thread acceptClientMsg = new Thread(AcceptMsg);
acceptClientMsg.Start(clientSocket);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}

/// <summary>
/// 接受消息
/// </summary>
public void AcceptMsg(object obj)
{
//强转为Socket类型
Socket client = obj as Socket;
//字节数组接受传来的信息 1024 * 64
byte[] buffer = new byte[client.ReceiveBufferSize];

//获取客户端的网络地址标识
IPEndPoint clientEndPoint = client.RemoteEndPoint as IPEndPoint;

try
{
while (true)
{
//接受消息
int len = client.Receive(buffer);
string str = Encoding.UTF8.GetString(buffer, 0, len);
Console.WriteLine("Receive {0} : {1} ：{2}", clientEndPoint.Address.ToString(), _port, str);
}
}
catch (SocketException e)
{
Console.WriteLine(e.Message);
_clientList.Remove(client);
}

}

/// <summary>
/// 给某一个客户端发送消息
/// </summary>
public void Send(string str, Socket client)
{
try
{
//string => byte[]
byte[] strBytes = Encoding.UTF8.GetBytes(str);
client.Send(strBytes);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}

/// <summary>
/// 发送给所有人
/// </summary>
public void SendAll(string str)
{
for (int i = 0; i < _clientList.Count; i++)
{
Send(str, _clientList[i]);
}
}

/// <summary>
/// 获取Ip地址
/// </summary>
public IPAddress GetIpv4(NetworkInterfaceType type)
{
NetworkInterface[] networkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
for (int i = 0; i < networkInterfaces.Length; i++)
{
if (type == networkInterfaces[i].NetworkInterfaceType && networkInterfaces[i].OperationalStatus == OperationalStatus.Up)
{
UnicastIPAddressInformationCollection ips = networkInterfaces[i].GetIPProperties().UnicastAddresses;
foreach (UnicastIPAddressInformation item in ips)
{
if (item.Address.AddressFamily == AddressFamily.InterNetwork)
{
return item.Address;
}
}
}
}
return null;
}

/// <summary>
/// 关闭套接字
/// </summary>
public void Close()
{
if (_clientList.Count > 0)
{
for (int i = 0; i < _clientList.Count; i++)
{
_clientList[i].Close();
}
}
_clientList.Clear();

_server.Close();

_acceptClientConnectThread.Abort();
}
}
}

TCPClient:

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;

namespace TcpClient
{
class Program
{
static void Main(string[] args)
{
Client client = new Client();
client.StartUp();

while (true)
{
string str = Console.ReadLine();
client.Send(str);
}
}
}

public class Client
{
private Socket _client;
private Thread _acceptServerMsg;

public void StartUp()
{
try
{
_client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//客户端连接
_client.Connect("192.168.30.35", 10000);

//接受消息的线程
_acceptServerMsg = new Thread(AcceptServerMsg);
_acceptServerMsg.Start();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}

public void AcceptServerMsg()
{
byte[] buffer = new byte[1024 * 64];

while (true)
{
try
{
int len = _client.Receive(buffer);
string str = Encoding.UTF8.GetString(buffer, 0, len);
Console.WriteLine("Reveive Msg From Server : {0}", str);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}

}
}

/// <summary>
/// 发送消息
/// </summary>
public void Send(string str)
{
try
{
//string => byte[]
byte[] strBytes = Encoding.UTF8.GetBytes(str);
_client.Send(strBytes);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}

}

/// <summary>
/// 关闭套接字
/// </summary>
public void Close()
{
if (_client.Connected)
{
_client.Close();
}

_acceptServerMsg.Abort();
}
}
}

阅读全文

0 0