private void button_Connect_Click(object sender, EventArgs e)
{
try
{
socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ip = IPAddress.Parse(this.textBox_IP.Text.Trim());
socketSend.Connect(ip, Convert.ToInt32(this.textBox_Port.Text.Trim()));
//实例化回调
setCallBack = new SetTextCallBack(SetValue);
receiveCallBack = new ReceiveMsgCallBack(SetValue);
this.richTextBox_Log.Invoke(setCallBack, "连接成功");
//开启一个新的线程不停的接收服务器发送消息的线程
threadReceive = new Thread(new ThreadStart(Receive));
//设置为后台线程
threadReceive.IsBackground = true;
threadReceive.Start();
}
catch (Exception ex)
{
MessageBox.Show("连接服务端出错:" + ex.ToString());
}
}
public void Listern()
{
try
{
IPAddress ip = IPAddress.Parse("192.168.1.128");
IPEndPoint ipe = new IPEndPoint(ip, 10000);
//IPEndPoint ipe = new IPEndPoint(IPAddress.Any, 10000);
socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socketWatch.Bind(ipe);
socketWatch.Listen(backlog);
MessageBox.Show("监听成功");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
//this.txt_Log.AppendText("监听成功" + " \r \n");
//btn_Start.Enabled = false;
////实例化回调
//setCallBack = new SetTextValueCallBack(SetTextValue);
receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
receiveIPCallBack = new ReceiveMsgCallBack(ReceiveMsgIP);
removeCallBack = new RemoveMsgCallBack(RemoveMsg);
//ipCallBack = new IPCallBack(IpChangeValue);
//setCmbCallBack = new SetCmbCallBack(AddCmbItem);
//sendCallBack = new SendFileCallBack(SendFile);
//Thread send = new Thread(Send);
//send.Start();
////创建线程
AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen))
{
IsBackground = true
};
AcceptSocketThread.Start(socketWatch);
}
/// <summary>
/// 连接
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void connect_Click(object sender, EventArgs e)
{
try
{
// IPHostEntry hostInfo = Dns.GetHostEntry("47.100.46.2");
// IPAddress ipAddress = hostInfo.AddressList[0];
// txt_IP = "superpao.aiweber.com/socket";
// txt_Port = "80";
socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ip = IPAddress.Parse("47.100.46.2");
socketSend.Connect(ip, 2120);
//实例化回调
setCallBack = new SetTextCallBack(SetValue);
receiveCallBack = new ReceiveMsgCallBack(SetValue);
// this.Label.Invoke(setCallBack, "连接成功");
this.label1.Text = "receive successful" + receiveCallBack.ToString();
// MessageBox.Show("lianjieco:" + setCallBack.ToString());
//开启一个新的线程不停的接收服务器发送消息的线程
threadReceive = new Thread(new ThreadStart(Receive));
//设置为后台线程
threadReceive.IsBackground = false;
threadReceive.Start();
}
catch (Exception ex)
{
MessageBox.Show("连接服务端出错:" + ex.ToString());
}
}
/// <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); SetTextValue；
//receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
//setCmbCallBack = new SetCmbCallBack(AddCmbItem);
//sendCallBack = new SendFileCallBack(SendFile);
setCallBack = SetTextValue;
receiveCallBack = ReceiveMsg;
setCmbCallBack = AddCmbItem;
sendCallBack = SendFile;
//创建线程
AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen));
AcceptSocketThread.IsBackground = true;
AcceptSocketThread.Start(socketWatch);
}
private void btnConnect_Click(object sender, EventArgs e)
{
try
{
//实例一个socket对象
client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ip = IPAddress.Parse(txtIp.Text);
int port = Convert.ToInt32(txtPort.Text);
IPEndPoint ie = new IPEndPoint(ip, port);
client.Connect(ie);
setCallBack = setValue;
receiveCallBack = receiveData;
this.rtxtRecv.Invoke(setCallBack, "已经成功连接到服务器！");
thReceive = new Thread(new ThreadStart(Receive));
thReceive.IsBackground = true;
thReceive.Start();
}
catch (Exception ex)
{
MessageBox.Show("连接服务器时出错：" + ex.ToString());
}
}
//开始监听按钮
private void btn_Listen_Click(object sender, EventArgs e)
{
try
{
//当点击开始监听的时候，在服务器端创建一个负责监听IP地址和socket号的socket
socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//获取IP地址
IPAddress ip = IPAddress.Parse(txtBox_IP.Text.Trim());
//绑定IP地址和端口号
IPEndPoint point = new IPEndPoint(ip, Convert.ToInt32(txtBox_Port.Text.Trim()));
socketWatch.Bind(point);
txtBox_Log.AppendText("监听成功" + "\r\n");
//开始监听：设置可以同时连接的最大请求数
socketWatch.Listen(10);
//实例化回调
//txt_Log增加值
setCallBack = new SetTextValueCallBack(SetTextValue);
receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
//创建线程
//StartListen是线程中要执行的方法，socketWatch是线程中方法的参数
AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen));
AcceptSocketThread.IsBackground = true;
AcceptSocketThread.Start(socketWatch);
}
catch { }
}
/// <summary>
/// 开始监听
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btn_Start_Click(object sender, EventArgs e)
{
//当点击开始监听的时候 在服务器端创建一个负责监听IP地址和端口号的Socket
int port = int.Parse(this.txt_Port.Text.Trim());
IPEndPoint ipe = new IPEndPoint(IPAddress.Any, port);//new IPEndPoint(IPAddress.Any, port);//IPAddress.Parse("180.175.63.122")
socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socketWatch.Bind(ipe);
socketWatch.Listen(20);
this.txt_Log.AppendText("监听成功" + " \r \n");
//实例化回调
setCallBack = new SetTextValueCallBack(SetTextValue);
receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
ipCallBack = new IPCallBack(IpChangeValue);
setCmbCallBack = new SetCmbCallBack(AddCmbItem);
sendCallBack = new SendFileCallBack(SendFile);
Thread send = new Thread(Send);
send.Start();
//创建线程
AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen));
AcceptSocketThread.IsBackground = true;
AcceptSocketThread.Start(socketWatch);
}
/// <summary>
/// 开始监听
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btn_Start_Click(object sender, EventArgs e)
{
string host = txt_IP.Text; //服务端IP地址
int port = int.Parse(txt_Port.Text);
socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//设置端口可复用
socketWatch.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
//连接服务端
socketWatch.Connect(host, port);
this.txt_Log.AppendText("连接成功" + " \r \n");
//实例化回调
setCallBack = new SetTextValueCallBack(SetTextValue);
receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
ipCallBack = new IPCallBack(IpChangeValue);
setCmbCallBack = new SetCmbCallBack(AddCmbItem);
sendCallBack = new SendFileCallBack(SendFile);
sendThread = new Thread(Send);
sendThread.Start();
threadReceive = new Thread(new ParameterizedThreadStart(Receive));
threadReceive.IsBackground = true;
threadReceive.Start(socketWatch);
}
private void btnListen_Click(object sender, EventArgs e)
{
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8888);
sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Bind(ipep); //设置监听地址
sock.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(sock);
}
///连接
private void button1_Click(object sender, EventArgs e)
{
string strIp = textBox1.Text.Trim() + @":" + textBox2.Text.Trim();
if (Servers.ContainsKey(strIp))
{
textBox3.AppendText(@"已与 " + strIp + @" 连接" + Environment.NewLine);
return;
}
try
{
socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ip = IPAddress.Parse(textBox1.Text.Trim());
socketSend.Connect(ip, Convert.ToInt32(textBox2.Text.Trim()));
Servers.Add(strIp, socketSend);
socketSend = null;
//实例化回调
setCallBack = SetValue;
receiveCallBack = SetValue;
setCmbCallBack = AddCmbItem;
comboBox1.Invoke(setCmbCallBack, strIp);
textBox3.Invoke(setCallBack, @"与 " + strIp + @" 连接成功");
button2.Enabled = true;
button3.Enabled = true;
//开启一个新的线程不停的接收服务器发送消息的线程
threadReceive = new Thread(Receive)
{
IsBackground = true
};
//设置为后台线程
ReceiveThreads.Add(strIp, threadReceive);
threadReceive.Start(strIp);
}
catch (Exception /*ex*/)
{
//MessageBox.Show(@"连接服务端出错:" + ex, @"出错啦", MessageBoxButtons.OK, MessageBoxIcon.Error);
socketSend?.Close();
textBox3.AppendText(@"与 " + strIp + @" 连接失败" + Environment.NewLine);
}
}
private void btn_Connect_Click(object sender, EventArgs e)
{
try {
SocketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress iP = IPAddress.Parse(txt_IP.Text.Trim());
int port = Convert.ToInt32(txt_Port.Text.Trim());
SocketSend.Connect(iP, port);
//实例化回调
setTextCallBack = new SetTextCallBack(SetValue);
receiveMsgCallBack = new ReceiveMsgCallBack(SetValue);
txt_Log.Invoke(setTextCallBack, "连接成功");
//开启一个新的线程不停的接收服务器发送的消息
threadReceive = new Thread(new ThreadStart(Receive));
threadReceive.IsBackground = true;
threadReceive.Start();
} catch (Exception ex) {
MessageBox.Show("连接服务器出错:" + ex.Message);
}
}
private void bt_startlisten_Click(object sender, EventArgs e)
{
socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); //创建一个用于监听的socket对象
IPAddress ip = IPAddress.Parse(this.txb_ip.Text.Trim());
IPEndPoint point = new IPEndPoint(ip, Convert.ToInt32(this.txb_port.Text.Trim())); //建立一个端点对象
socketWatch.Bind(point); //绑定端点
this.txt_log.AppendText("监听成功" + " \r\n");
socketWatch.Listen(10); //开始帧听，最大接受10个请求
//实例化回调
setCallBack = new SetTextValueCallBack(SetTextValue);
receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
setCmbCallBack = new SetCmbCallBack(AddCmbItem);
AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen));
AcceptSocketThread.IsBackground = true; //后台运行
AcceptSocketThread.Start(socketWatch); //启动线程，socketWatch作为线程的数据对象
this.bt_startlisten.Enabled = false;
this.bt_stoplisten.Enabled = true;
}
private void BtnStartServer_Click(object sender, RoutedEventArgs e)
{
#region 绑定回调函数
setCallBack = new SetTextValueCallBack(SetTextValue);
receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
setCmbCallBack = new SetCmbCallBack(AddCmbItem);
sendCallBack = new SendFileCallBack(SendFile);
#endregion
//监听
Socket socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socketWatch.Bind(point);
socketWatch.Listen(100);
SetTextValue(string.Format("服务器{0}:开启监听", socketWatch.LocalEndPoint.ToString()));
//创建监听线程
AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen));
AcceptSocketThread.IsBackground = true;
AcceptSocketThread.Start(socketWatch);
this.cmbSocket.ItemsSource = dicSocket.Keys;
}
/// <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(txt_IP.Text.Trim());
//端口
int port = Convert.ToInt32(txt_Port.Text.Trim());
//终结点：
//在Internet中，TCP/IP 使用套接字(一个网络地址和一个服务端口号)来唯一标识设备。网络地址(IP)标识网络上的特定设备；端口号(Port)标识要连接到的该设备上的特定服务。
//网络地址和服务端口的组合称为终结点，在 .NET 框架中正是由 EndPoint 类表示这个终结点，它提供表示网络资源或服务的抽象，用以标志网络地址等信息。
//.Net同时也为每个受支持的地址族定义了 EndPoint 的子代；对于 IP 地址族，该类为 IPEndPoint。IPEndPoint 类包含应用程序连接到主机上的服务所需的主机和端口信息。
/**
* 作者：UnityAsk
* 链接：https://www.jianshu.com/p/ffefd038ba11
* 来源：简书
* 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
* **/
//终结点
IPEndPoint point = new IPEndPoint(ip, port);
//绑定IP地址和端口号
SocketWatch.Bind(point);
txt_Log.AppendText("监听成功" + "\r\n");
//开始监听：设置最大可以同时连接多少个请求
SocketWatch.Listen(10);
//实例化回调
SetCallBack = new SetTextValueCallBack(SetTextValue);
ReceiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
SetCmbCallBack = new SetCmbItemCallBack(AddCmbItem);
SendCallBack = new SendFileCallBack(SendFile);
//创建线程
AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen));
AcceptSocketThread.IsBackground = true;
AcceptSocketThread.Start(SocketWatch);
}
///开始监听
private void button1_Click(object sender, EventArgs e)
{
button1.Enabled = false;
//创建一个负责监听IP地址和端口号的Socket
socketListen = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//获取ip地址
IPAddress ip = IPAddress.Parse(textBox1.Text.Trim());
//创建端口号
IPEndPoint point = new IPEndPoint(ip, Convert.ToInt32(textBox2.Text.Trim()));
//绑定IP地址和端口号
try
{
socketListen.Bind(point);
}
catch
{
textBox4.AppendText(@"监听失败" + Environment.NewLine);
button1.Enabled = true;
return;
}
textBox4.AppendText(@"监听成功" + Environment.NewLine);
button2.Enabled = true;
button5.Enabled = true;
//开始监听:设置最大可以同时连接多少个请求
socketListen.Listen(MAXClients);
//实例化回调
setCallBack = SetTextValue;
receiveCallBack = ReceiveMsg;
setCmbCallBack = AddCmbItem;
sendCallBack = SendFile;
//创建线程
AcceptSocketThread = new Thread(StartListen)
{
IsBackground = true
};
AcceptSocketThread.Start(socketListen);
}
private void Connect()
{
var signal = Encoding.Default.GetBytes($"nedraghs:{MoudleCode}:");
socketWatch.Send(signal);
//实例化回调
setCallBack = new SetTextValueCallBack(SetTextValue);
receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
SendByteCallBack = new SendFromSerialportCallBack(SendFromSerialportToSocket);
restartapp = new ReStartApp(ReStart);
//ipCallBack = new IPCallBack(IpChangeValue);
//setCmbCallBack = new SetCmbCallBack(AddCmbItem);
//sendCallBack = new SendFileCallBack(SendFile);
//sendThread = new Thread(Send);
//sendThread.Start();
threadReceive = new Thread(new ParameterizedThreadStart(Receive));
threadReceive.IsBackground = true;
threadReceive.Start(socketWatch);
isConnect = true;
//txt_Log.Invoke(receiveCallBack, "成功连接至服务器");
}
//接收客户端发送消息的线程
//Thread threadReceive;
//转发消息的线程
//Thread zhaunxianchen;
/// <summary>
/// 开始监听
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btn_Start_Click(object sender, EventArgs e)
{
try
{
button2.Enabled = true;
UDPjiantin();
//当点击开始监听的时候 在服务器端创建一个负责监听IP地址和端口号的Socket
socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//获取ip地址
IPAddress ip = IPAddress.Parse(this.textBox1.Text.Trim());
//创建端口号
IPEndPoint point = new IPEndPoint(ip, Convert.ToInt32(this.textBox2.Text.Trim()));
//绑定IP地址和端口号
socketWatch.Bind(point);
//开始监听:设置最大可以同时连接多少个请求
socketWatch.Listen(60);
//实例化回调
setCallBack = new SetTextValueCallBack(SetTextValue);
receiveCallBack = new ReceiveMsgCallBack(ReceiveMsg);
setCmbCallBack = new SetCmbCallBack(AddCmbItem);//绑定soket
sendCallBack = new SendFileCallBack(SendFile);
//查昵称
zhangfalixian = new ReceiveMsgCallBack(zhuangfa);
//创建线程
AcceptSocketThread = new Thread(new ParameterizedThreadStart(StartListen));
AcceptSocketThread.IsBackground = true;
AcceptSocketThread.Start(socketWatch);
MessageBox.Show("服务器开启成功");
button1.Enabled = false;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
button2.Enabled = false;
button1.Enabled = true;
IsUdpcRecvStart = false;
}
}
private void StartConnection(Socket listenSocket)
{
try
{
listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPAddress ip = IPAddress.Parse(this.ipAddress.Text.Trim());
int port = Convert.ToInt32(this.port.Text.Trim());
listenSocket.Connect(ip, port);
setCallBack = new SetTextCallBack(SetValue);
receiveCallBack = new ReceiveMsgCallBack(SetValue);
this.clientLog.Invoke(setCallBack, "[" + DateTime.Now.ToString() + "] connect successfully!");
//create a new thread for communicating
threadReceive = new Thread(new ParameterizedThreadStart(Receive));
threadReceive.IsBackground = true;
threadReceive.Start(listenSocket);
}
catch (Exception ex)
{
MessageBox.Show("DAP_emulator connection error: \n" + ex.Message);
}
}
/// <summary>
/// TcpClient
/// </summary>
/// <param name="serverIp">服务器ip'</param>
/// <param name="serverPort">服务器端口</param>
/// <param name="receiveMsgCallBack">接受消息回调函数</param>
public TTcpClient(string serverIp, int serverPort, ReceiveMsgCallBack receiveMsgCallBack)
{
ServerIp = serverIp;
ServerPort = serverPort;
_receiveMsgCallBack = receiveMsgCallBack;
}
