C# Socket TCP 编程,客户端与服务端连接,发送字符串,文件

最新推荐文章于 2024-05-27 21:36:29 发布
最新推荐文章于 2024-05-27 21:36:29 发布
阅读量1.3w 收藏 32
点赞数 5
分类专栏： C# 文章标签： c# socket winform 发送文件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nepture911122/article/details/56831828
版权

做了个winform的Socket服务端和客户端,能实现发送消息&文字


以下是图片和一些关键点,最后是代码,注释不多



服务端

服务端创建一个socket对象

参数 :寻址方案,ip版本4 ;套接字类型,字节流 ;协议,TCP

Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

这时候可以在外边创建new一个空的socket对象比如serverSocket.来保存上面创建的对象,这样其他地方就能使用这个socket

例外,在外部创建一个List<Socket> list 来保存连客户端socket对象.后面要用

socket需要ip地址和port,注意参数转换类型

socket.Bind(new IPEndPoint(IPAddress.Parse(txtIP.Text.ToString()), int.Parse(txtPort.Text)));

设置连接等待队列的数量

socket.Listen(10);

开始服务,等待客户端连接,这时候需要开另外一个线程 来做这些事情,AcceptClientConnect是自己写的一个方法,将socket传给它

ThreadPool.QueueUserWorkItem(new WaitCallback(this.AcceptClientConnect), socket);

下面是AcceptClientConnect的代码, 当有客户端连接时,创建一个Socket对象.变量名为proxSocket,并且保存到list中,方便以后使用,另外,需要在创建一个线程来处理该客户端socket发送过来的数据.

public void AcceptClientConnect(object socket)
        {
            var serverSocket = socket as Socket;
            this.AppendTextToTxtLog("服务器端开始接受客户端的链接");
            while (true)
            {
                try
                {
                    var proxSocket = serverSocket.Accept();
                    this.AppendTextToTxtLog(string.Format("客户端{0}连接上了", proxSocket.RemoteEndPoint.ToString()));
                    ClientProxClentList.Add(proxSocket);


                    //接受消息
                    ThreadPool.QueueUserWorkItem(new WaitCallback(this.ReceiveData), proxSocket);
                }
                catch (Exception)
                {
                }
                
            }
        }

其中AppendTextToTxtLog方法是给主窗口中传递文本信息,因为txtLog这个控件不是监听服务端连接的线程创建的.所以要用异步来让它把新消息复制到txtLog中,代码中if来判断是否是txtLog当前线程的控件 

 public void AppendTextToTxtLog(string txt)
        {
            if (txtLog.InvokeRequired)
            {
                txtLog.BeginInvoke(new Action<string>(s =>
                {
                    this.txtLog.Text = string.Format("{0}\r\n{1}", s, txtLog.Text);
                }), txt);
            }
            else
            {
                this.txtLog.Text = string.Format("{0}\r\n{1}", txt, txtLog.Text);
            }
        }
下面是处理客户端发送过来的数据的代码,new一个byte[]数组,变量名为data,代销为1024*1024,用来保存客户端发来的数据. int  readlen是实际接收到的数据的长度(data中没用的到部分会自动为null),服务端和客户端通信的时候,数据长度是大于0的.当数据长度等于0 的时候,说明客户端要断开连接,代码中有这个判断,还有try,catch捕获异常(这里处理的不怎么好),最后.当复合条件.发送过来的数据转换成字符串,这里用到了有效长度,截取,转换为字符串,添加到消息文本框中. 

 public void ReceiveData(object obj)
        {
            Socket proxSocket = obj as Socket;
            byte[] data = new byte[1024 * 1024];
            while (true)
            {
                int readLen = 0;
                try
                {
                    readLen = proxSocket.Receive(data, 0, data.Length, SocketFlags.None);
                }
                catch (Exception ex)
                {
                    //异常退出时
                    AppendTextToTxtLog(string.Format("客户端{0}非正常退出", proxSocket.RemoteEndPoint.ToString()));
                    ClientProxClentList.Remove(proxSocket);
                    StopConnetct(proxSocket);
                    return;
                }
                if (readLen<=0)
                {
                    //客户端正常退出
                    AppendTextToTxtLog(string.Format("客户端:{0}正常退出", proxSocket.RemoteEndPoint.ToString()));
                    ClientProxClentList.Remove(proxSocket);
                    StopConnetct(proxSocket);
                    return;//方法结束->终结当前接受客户端数据的异步线程
                }
                string txt = Encoding.Default.GetString(data, 0, readLen);
                AppendTextToTxtLog(string.Format("接收到客户端{0}的消息{1}",proxSocket.RemoteEndPoint.ToString(),txt));
            }
        }
一下是发送消息的代码 ,这个客户端能发送字符串,文件和窗口晃动,在原本发送的byte[] data前面在增加一位,为1 的时候是发送字符串,2发送晃动.3发送文件,data数组前面加一位,new用一个新数组result,长度是data.length+1,之后用到了Buffer.BlockCopy()方法,参数分别是(原数组,原数组的开始位置,目标数组,目标数组的开始位置,原数组中取多长数据)

发送数据,客户端对象.Send(要发送的byte数组,开始位置,长度,发送接收行为),一般发送接收行为用SocketFlags.None就可以了.发送的时候遍历一下list中的客户端对象.判断一下是否连接.

 private void btnSend_Click(object sender, EventArgs e)
        {
            foreach (var proxSocket in ClientProxClentList)
            {
                if (proxSocket.Connected)
                {
                    //原始的字符串转换成的字节数组
                    byte[] data = Encoding.Default.GetBytes(txtSendMsg.Text);
                    //在头部加上标记字节
                    byte[] result = new byte[data.Length + 1];
                    //头部协议字节 1:代表字符串
                    result[0] = 1;
                    Buffer.BlockCopy(data, 0, result, 1, data.Length);
                    proxSocket.Send(result, 0, result.Length,SocketFlags.None);
                }
            }
        }
发送文件的方法,new一个新的byte数组,第一位设置为3,然后读取文件,转换为byte[]data,还是用Buffer.BlockCopy(),整合到变量名为result的byte数组中,遍历list中的客户端对象,如果是连接的,那么发送 


private void button2_Click(object sender, EventArgs e)
        {
            using (OpenFileDialog ofd =new OpenFileDialog())
            {
                if (ofd.ShowDialog()!=DialogResult.OK)
                {
                    return;
                }
                byte[] data = File.ReadAllBytes(ofd.FileName);
                byte[] result = new byte[data.Length + 1];
                result[0] = 3;
                Buffer.BlockCopy(data, 0, result, 1,data.Length);

                foreach (var proxSocket in ClientProxClentList)
                {
                    if (!proxSocket.Connected)
                    {
                        continue;
                    }
                    proxSocket.Send(result, SocketFlags.None);
                }
            }
           
        }
最后一个是晃动的,只要发一个第一位是2的byte数组过去就好 

 private void button1_Click(object sender, EventArgs e)
        {
            foreach (var proxSocket in ClientProxClentList)
            {
                if (proxSocket.Connected)
                {
                    proxSocket.Send(new byte[] { 2 }, SocketFlags.None);
                }
            }
        }

下面是服务端的整体代码 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace ChatDemo
{
    public partial class Mainfrm : Form
    {
        public Mainfrm()
        {
            InitializeComponent();
        }
        private Socket serverSocket;
        List<Socket> ClientProxClentList = new List<Socket>();
        private bool state = false;
        private void btnStart_Click(object sender, EventArgs e)
        {
            if (!state)
            {
                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                serverSocket = socket;
                //ip port
                socket.Bind(new IPEndPoint(IPAddress.Parse(txtIP.Text.ToString()), int.Parse(txtPort.Text)));
                //listen
                socket.Listen(10);//连接等待队列
                ThreadPool.QueueUserWorkItem(new WaitCallback(this.AcceptClientConnect), socket);
                state = true;
                btnStart.Text = "停止服务";
            }
            else
            {
                try
                {
                    serverSocket.Close();
                    serverSocket.Shutdown(SocketShutdown.Both);
                }
                catch (Exception)
                {
                    state = false;
                    btnStart.Text = "开始服务";
                }
                
                
                

            }
            //对象
           
        }

        //日志文本框追加数据
        public void AppendTextToTxtLog(string txt)
        {
            if (txtLog.InvokeRequired)
            {
                txtLog.BeginInvoke(new Action<string>(s =>
                {
                    this.txtLog.Text = string.Format("{0}\r\n{1}", s, txtLog.Text);
                }), txt);
            }
            else
            {
                this.txtLog.Text = string.Format("{0}\r\n{1}", txt, txtLog.Text);
            }
        }
        public void AcceptClientConnect(object socket)
        {
            var serverSocket = socket as Socket;
            this.AppendTextToTxtLog("服务器端开始接受客户端的链接");
            while (true)
            {
                try
                {
                    var proxSocket = serverSocket.Accept();
                    this.AppendTextToTxtLog(string.Format("客户端{0}连接上了", proxSocket.RemoteEndPoint.ToString()));
                    ClientProxClentList.Add(proxSocket);

                    //接受消息
                    ThreadPool.QueueUserWorkItem(new WaitCallback(this.ReceiveData), proxSocket);
                }
                catch (Exception)
                {
                }
                
            }
        }
        public void ReceiveData(object obj)
        {
            Socket proxSocket = obj as Socket;
            byte[] data = new byte[1024 * 1024];
            while (true)
            {
                int readLen = 0;
                try
                {
                    readLen = proxSocket.Receive(data, 0, data.Length, SocketFlags.None);
                }
                catch (Exception ex)
                {
                    //异常退出时
                    AppendTextToTxtLog(string.Format("客户端{0}非正常退出", proxSocket.RemoteEndPoint.ToString()));
                    ClientProxClentList.Remove(proxSocket);
                    StopConnetct(proxSocket);
                    return;
                }
                if (readLen<=0)
                {
                    //客户端正常退出
                    AppendTextToTxtLog(string.Format("客户端:{0}正常退出", proxSocket.RemoteEndPoint.ToString()));
                    ClientProxClentList.Remove(proxSocket);
                    StopConnetct(proxSocket);
                    return;//方法结束->终结当前接受客户端数据的异步线程
                }
                string txt = Encoding.Default.GetString(data, 0, readLen);
                AppendTextToTxtLog(string.Format("接收到客户端{0}的消息{1}",proxSocket.RemoteEndPoint.ToString(),txt));
            }
        }

        private void btnSend_Click(object sender, EventArgs e)
        {
            foreach (var proxSocket in ClientProxClentList)
            {
                if (proxSocket.Connected)
                {
                    //原始的字符串转换成的字节数组
                    byte[] data = Encoding.Default.GetBytes(txtSendMsg.Text);
                    //在头部加上标记字节
                    byte[] result = new byte[data.Length + 1];
                    //头部协议字节 1:代表字符串
                    result[0] = 1;
                    Buffer.BlockCopy(data, 0, result, 1, data.Length);
                    proxSocket.Send(result, 0, result.Length,SocketFlags.None);
                }
            }
        }

        private void StopConnetct(Socket proxSocket)
        {
            try
            {
                if (proxSocket.Connected)
                {
                    proxSocket.Shutdown(SocketShutdown.Both);
                    proxSocket.Close(100);
                }
            }
            catch (Exception ex)
            {
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            using (OpenFileDialog ofd =new OpenFileDialog())
            {
                if (ofd.ShowDialog()!=DialogResult.OK)
                {
                    return;
                }
                byte[] data = File.ReadAllBytes(ofd.FileName);
                byte[] result = new byte[data.Length + 1];
                result[0] = 3;
                Buffer.BlockCopy(data, 0, result, 1,data.Length);

                foreach (var proxSocket in ClientProxClentList)
                {
                    if (!proxSocket.Connected)
                    {
                        continue;
                    }
                    proxSocket.Send(result, SocketFlags.None);
                }
            }
           
        }

        private void button1_Click(object sender, EventArgs e)
        {
            foreach (var proxSocket in ClientProxClentList)
            {
                if (proxSocket.Connected)
                {
                    proxSocket.Send(new byte[] { 2 }, SocketFlags.None);
                }
            }
        }
    }
}



客户端

点击按钮连接Server,在外面创建一个socket对象名称为ClientSocket.方便其他地方调用,连接成功后new一个线程名称thread来处理接受到的消息,注意.thread设置为后台线程thread.IsBackground = true,线程开始的时候把当前的socket对象作为参数给它,thread.Start(ClientSocket);

private void btnConnect_Click(object sender, EventArgs e)
        {
            Socket socket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            ClientSocket = socket;
            try
            {
                socket.Connect(IPAddress.Parse(txtIP.Text), int.Parse(txtPort.Text));
            }
            catch (Exception ex)
            {                
                MessageBox.Show("Bad");
                return;
            }            
            AppendTextToTxtLog(string.Format("服务端{0}已连接",ClientSocket.RemoteEndPoint.ToString()));
            Thread thread = new Thread(new ParameterizedThreadStart(ReceiveData));
            thread.IsBackground = true;
            thread.Start(ClientSocket);
        }

消息接受方法ReceiveData(), socket对象.Receive(data, 0, data.Length, SocketFlags.None);返回值是实际接受的字节流长度,变量名readLen,后面要用. 

public void ReceiveData(object obj)
        {
            Socket proxSocket = obj as Socket;
            byte[] data = new byte[1024 * 1024];
            while (true)
            {
                int readLen = 0;
                try
                {
                    readLen = proxSocket.Receive(data, 0, data.Length, SocketFlags.None);
                }
                catch (Exception)
                {
                    //异常退出时
                    AppendTextToTxtLog(string.Format("服务端{0}非正常退出", proxSocket.RemoteEndPoint.ToString()));
                    StopConnetct();
                    return;
                }
                if (readLen <= 0)
                {
                    //客户端正常退出
                    AppendTextToTxtLog(string.Format("服务端:{0}正常退出", proxSocket.RemoteEndPoint.ToString()));                    
                    StopConnetct();
                    return;//方法结束->终结当前接受客户端数据的异步线程
                }
                //接受的数据中第一个字节如果是1,那么是字符串.2是闪屏.3是文件
                if (data[0]==1)
                {
                    string strMsg = ProcessRecieveString(data, readLen);
                    AppendTextToTxtLog(string.Format("接收到服务端{0}的消息{1}", proxSocket.RemoteEndPoint.ToString(), strMsg));
                }
                else if (data[0] == 2)
                {
                    ProcessRecieveShake();
                }
                else if (data[0]==3)
                {
                    ProcessRecieveFile(data, readLen);
                }
            }
        }

下面是对字节流首位分别是1,2,3的处理方法

 public string ProcessRecieveString(byte[] data,int readLen)
        {
            string str = Encoding.Default.GetString(data, 1, readLen);
            return str;
        }
        public void ProcessRecieveShake()
        {
            Point oldLocation = this.Location;
            Random r = new Random();
            
            if (this.InvokeRequired)
            {
                txtLog.BeginInvoke(new Action<Point,Random>(Shake),oldLocation,r);
            }
            else
            {
                Shake(oldLocation, r);
            }         
        }

        private void Shake(Point oldLocation, Random r)
        {
            for (int i = 0; i < 50; i++)
            {
                this.Location = new Point(r.Next(oldLocation.X - 5, oldLocation.X + 5), r.Next(oldLocation.Y - 5, oldLocation.Y + 5));
                Thread.Sleep(50);
                this.Location = oldLocation;
            }
        }

        public void ProcessRecieveFile(byte[] data,int readLen)
        {
            using (SaveFileDialog sfd = new SaveFileDialog())
            {
                sfd.DefaultExt = "txt";
                sfd.Filter = "文本文件(*.txt)|*.txt|所有文件(*.*)|*.*";
                if (sfd.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }
                byte[] fileData = new byte[readLen - 1];
                Buffer.BlockCopy(data, 1, fileData, 0, readLen - 1);
                File.WriteAllBytes(sfd.FileName, fileData);
                AppendTextToTxtLog(string.Format("接收到文件,已保存到{0}", sfd.FileName));
            }
        }
下面是发送消息的代码(和服务端的基本差不多) 
 private void btnSend_Click(object sender, EventArgs e)
        {
            // AppendTextToTxtLog("123");
            if (ClientSocket==null)
            {
                return;
            }
            if (ClientSocket.Connected)
            {
                byte[] data = Encoding.Default.GetBytes(txtSendMsg.Text);
                ClientSocket.Send(data, 0, data.Length, SocketFlags.None);
            }
            
        }

下面是客户端的整体代码 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace SocketClient
{
    public partial class Mianfrm : Form
    {
        public Mianfrm()
        {
            InitializeComponent();
            //Control.CheckForIllegalCrossThreadCalls = false;
        }
        public Socket ClientSocket { get; set;   }
        private void btnConnect_Click(object sender, EventArgs e)
        {
            Socket socket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            ClientSocket = socket;
            try
            {
                socket.Connect(IPAddress.Parse(txtIP.Text), int.Parse(txtPort.Text));
            }
            catch (Exception ex)
            {                
                MessageBox.Show("Bad");
                return;
            }            
            AppendTextToTxtLog(string.Format("服务端{0}已连接",ClientSocket.RemoteEndPoint.ToString()));
            Thread thread = new Thread(new ParameterizedThreadStart(ReceiveData));
            thread.IsBackground = true;
            thread.Start(ClientSocket);
        }
        public void ReceiveData(object obj)
        {
            Socket proxSocket = obj as Socket;
            byte[] data = new byte[1024 * 1024];
            while (true)
            {
                int readLen = 0;
                try
                {
                    readLen = proxSocket.Receive(data, 0, data.Length, SocketFlags.None);
                }
                catch (Exception)
                {
                    //异常退出时
                    AppendTextToTxtLog(string.Format("服务端{0}非正常退出", proxSocket.RemoteEndPoint.ToString()));
                    StopConnetct();
                    return;
                }
                if (readLen <= 0)
                {
                    //客户端正常退出
                    AppendTextToTxtLog(string.Format("服务端:{0}正常退出", proxSocket.RemoteEndPoint.ToString()));                    
                    StopConnetct();
                    return;//方法结束->终结当前接受客户端数据的异步线程
                }
                //接受的数据中第一个字节如果是1,那么是字符串.2是闪屏.3是文件
                if (data[0]==1)
                {
                    string strMsg = ProcessRecieveString(data, readLen);
                    AppendTextToTxtLog(string.Format("接收到服务端{0}的消息{1}", proxSocket.RemoteEndPoint.ToString(), strMsg));
                }
                else if (data[0] == 2)
                {
                    ProcessRecieveShake();
                }
                else if (data[0]==3)
                {
                    ProcessRecieveFile(data, readLen);
                }
            }
        }
        public string ProcessRecieveString(byte[] data,int readLen)
        {
            string str = Encoding.Default.GetString(data, 1, readLen);
            return str;
        }
        public void ProcessRecieveShake()
        {
            Point oldLocation = this.Location;
            Random r = new Random();
            
            if (this.InvokeRequired)
            {
                txtLog.BeginInvoke(new Action<Point,Random>(Shake),oldLocation,r);
            }
            else
            {
                Shake(oldLocation, r);
            }         
        }

        private void Shake(Point oldLocation, Random r)
        {
            for (int i = 0; i < 50; i++)
            {
                this.Location = new Point(r.Next(oldLocation.X - 5, oldLocation.X + 5), r.Next(oldLocation.Y - 5, oldLocation.Y + 5));
                Thread.Sleep(50);
                this.Location = oldLocation;
            }
        }

        public void ProcessRecieveFile(byte[] data,int readLen)
        {
            using (SaveFileDialog sfd = new SaveFileDialog())
            {
                sfd.DefaultExt = "txt";
                sfd.Filter = "文本文件(*.txt)|*.txt|所有文件(*.*)|*.*";
                if (sfd.ShowDialog(this) != DialogResult.OK)
                {
                    return;
                }
                byte[] fileData = new byte[readLen - 1];
                Buffer.BlockCopy(data, 1, fileData, 0, readLen - 1);
                File.WriteAllBytes(sfd.FileName, fileData);
                AppendTextToTxtLog(string.Format("接收到文件,已保存到{0}", sfd.FileName));
            }
        }
        public void AppendTextToTxtLog(string txt)
        {
            if (txtLog.InvokeRequired)
            {
                txtLog.BeginInvoke(new Action<string>(s =>{this.txtLog.Text = String.Format("{0}\r\n{1}", s, txtLog.Text);}), txt);
            }
            else
            {
                this.txtLog.Text = string.Format("{0}\r\n{1}", txt, txtLog.Text);
            }
        }
        private void btnSend_Click(object sender, EventArgs e)
        {
            // AppendTextToTxtLog("123");
            if (ClientSocket==null)
            {
                return;
            }
            if (ClientSocket.Connected)
            {
                byte[] data = Encoding.Default.GetBytes(txtSendMsg.Text);
                ClientSocket.Send(data, 0, data.Length, SocketFlags.None);
            }
            
        }
        private void StopConnetct()
        {
            try
            {
                if (ClientSocket.Connected)
                {
                    ClientSocket.Shutdown(SocketShutdown.Both);
                    ClientSocket.Close(100);
                }
            }
            catch (Exception ex)
            {
            }
        }

        private void Mianfrm_FormClosing(object sender, FormClosingEventArgs e)
        {
            StopConnetct();

        }

        private void Mianfrm_Load(object sender, EventArgs e)
        {
            AppendTextToTxtLog("请单击连接到服务器");
        }
    }
}

最后是软件的界面,






凡凡1990
关注
  • 5
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
C# Socket 网络信息传输
againknow的博客
01-24 3101
C# Socket 网络信息传输
C# Socket_服务端向指定的客户端发送消息(包含服务器)
12-24
本文将详细讲解如何使用C# Socket实现服务端向指定的客户端发送消息，以及涉及到的相关知识点。 首先，我们要理解Socket的基本概念。Socket是网络通信中的一个端点，它允许两个程序通过网络进行数据交换。在C#中，`...
C#使用tcp协议socket收发字符串文本数据，比如json字符串，xml字符串或者是纯文本数据
09-02
该程序用C#编写，基于第三方类库实现TCP协议收发文本数据，比如Json，xml等字符串数据。SharpSocket底层采用Windows的IOCP模型,是最稳定和高效的Socket编程模型。SharpSocket代码经过精心优化, 有些直接在IL层编写，处理数据更快速!
C# socket发送(接收）文件
06-23
C#使用socket发送（接收）文件的程序，任何文件均可。 其中SingleSendForm是一次发送一个文件，MultiSendForm可以一次选择多个文件，然后依次发送。
使用C#设计一个Tcp客户端
最新发布
2301_79762773的博客
05-27 1135
1、服务器首先调用系统API创建一个套接字，指定使用IPv4或IPv6，以及TCP协议。2、当有客户端连接请求到来时，服务器从监听队列中取出一个连接请求，并为该请求创建一个新的套接字（通常称为“已连接套接字”或“客户端套接字”），与客户端进行通信。原始套接字（即监听套接字）则继续监听其他连接请求。3、客户端使用套接字尝试连接到服务器的IP地址和端口号。TCP协议会进行三次握手来建立连接。4、数据传输完成后，客户端调用系统API关闭与服务器的连接，释放相关资源。
C# Winform 实现TCP发消息
chinaherolts2008的博客
01-20 1564
c#教程https://www.xin3721.com/eschool/CSharpxin3721/ 这篇文章主要介绍了C# Winform 实现TCP发消息的示例，帮助大家更好的理解和学习使用c#技术，感兴趣的朋友可以了解下 目录 服务端： 窗体 代码： 客户端： 窗体 代码 运行结果： 服务端： 窗体 ​ 代码： 1 2 3 4 5 6 7 8 9 10
AS socket 实现简单的服务器与客户端的通信
qq_43687905的博客
06-01 1406
代码实现： 1、Socket服务端的编写： 在AS目录的Java文件下新建一个.Java：（把以下代码粘上） public class SocketServer { public static void main(String[] args) throws IOException { //1.创建一个服务器端Socket，即ServerSocket，指定绑定的端口，并监听此端口 ServerSoc...
同步传输字符串
见证大牛成长之路的专栏
04-19 7349
同步传输字符串 接下来考虑着一种情况,完成一个简单的文本通信:(1).客户端将字符串发送到服务端,服务端接受字符串并显示(2).服务端将字符串由英文的小写转换为大写,然后发回给客户端,客户端接受并显示. 客户端发送,服务端接受并输出 1.服务端程序 可以在TcpClient上调用GetStream()方法来获得连接到远程计算机的网络流NetworkStream.当在客户端调用时,它获得连接服务端的
C#简单实现发送socket字符串
08-26
本文将详细讲解如何使用C#简单实现socket字符串发送。首先，我们要了解Socket的基本概念和工作原理。 Socket，通常被称为套接字，是网络通信中的接口，它允许应用程序通过网络发送和接收数据。在C#中，我们可以使用...
c# WinForm 使用Socket实现简单实现服务端与客户端连接，实现消息发送，服务器客户端重连
04-29
总结起来，这个项目展示了如何在C#的WinForm环境中使用Socket进行网络通信，包括服务端的监听、客户端的连接、消息发送和异常处理，特别是断线重连的机制，这对于开发稳定可靠的网络应用程序至关重要。通过实践和...
C#网络通信之TCP连接，客户端和服务端的tcp收发信息
04-29
本篇将深入探讨C#中如何实现TCP连接，包括客户端和服务端的TCP收发信息。 首先，TCP是一种面向连接的、可靠的传输协议，它确保了数据的顺序传输和错误校验。在C#中，我们主要通过System.Net.Sockets命名空间中的...
C#Socket通信基础（异步Socket通信TCP）服务器与客户端
CoffeMilk的博客
10-28 1473
一、效果图 二、服务器端代码（源码下载地址：https://download.csdn.net/download/xiaochenxihua/10748789） using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawi...
C# 实现socket通讯程序（服务器端）
Cheney的博客
06-20 5629
上一篇说的是客户端https://blog.csdn.net/cj151525/article/details/93061212，那么这篇就要聊聊服务器端的编程了。具体的计算机网络基础知识请参考这个网站：https://www.cnblogs.com/dotnet261010/p/6211900.html 先看张原理图： 服务器端： 第一步：创建一个用于监听连接的Socket对像； 第...
C#利用Socket实现客户端通信（包含：服务器和客户端通信，客户端通过服务器和客户端通信）
ba_wang_mao的专栏
07-21 8184
实验功能： 设计程序，分别构建通信的两端:服务器端和客户端应用程序,套接字类型为面向连接的Socket,自己构建双方的应答模式，实现双方的数据的发送和接收（S发给C，C发给S）。 服务端程序能响应单个或任意多个客户端连接请求；服务端能向单个客户发送消息，支持群发消息给所有客户端； 通信的双方具备异常响应功能，包括对方异常退出的处理。如果客户端退出，服务器有响应；反之亦然。 客户端之间直接通信，C与C之间直接通信（不是通过S传递）。 设计思路： 服务..
C#使用Socket实现服务器和客户端通信之客户端代码
lcmsir的博客
04-03 1456
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....
Qt实现客户端与服务器消息发送与文件传输
热门推荐
冯Jungle的个人博客
05-01 3万+
客户端与服务器之间的数据传送在很多案例场景里都会有应用。这里Jungle用Qt来简单设计实现一个场景，即： ①两端：服务器QtServer和客户端QtClient ②功能：服务端连接客户端，两者能够互相发送消息，传送文件，并且显示文件传送进度。 环境：VS2008+Qt4.8.6+Qt设计师 1.基本概念 客户端与服务器的基本概念不说了，关于TCP通信的三次握手等等，在经典教材谢希仁...
C# socket异步通信服务器和客户端
ba_wang_mao的专栏
07-14 836
本文章向大家介绍C# socket异步通信服务器和客户端，主要包括C# socket异步通信服务器和客户端使用实例、应用技巧、基本知识点总结和需要注意事项，具有一定的参考价值，需要的朋友可以参考一下。 服务器代码 只要客户端连接进来就会接收到Server received data using System; using System.Text; using System.Net.Sockets; using System.Net; class Program { ///...
C# winform socket一个服务端和多个客户端进行通信
yueguanyun的专栏
04-21 2万+
 参看此链接http://blog.csdn.net/zdyueguanyun/article/details/51207727 在上述代码的基础上进行了修改，包括一些捕获异常以及按钮的应用，扩充了一个listbox确保服务端可以选择和不同的客户端进行通信 代码： using System; using System.Collections.Generic; using System.
c#中tcp客户端连接服务端建立tcp通讯
07-13
在计算机编程中，它也是一种编程语言，C语言，在计算机领域广泛应用。C语言的设计简单而灵活，容易学习和使用，在软件开发中有着重要的地位。此外，C还是一个音乐学术语，在音乐表示法中，它是一个音符，代表中音...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值