C#socket通信

最新推荐文章于 2024-01-17 23:16:03 发布
最新推荐文章于 2024-01-17 23:16:03 发布
阅读量128 收藏
点赞数
文章标签： 网络 运维 操作系统
原文链接：https://my.oschina.net/u/3026393/blog/1592674
版权

服务端

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;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;

namespace 我的聊天程序
{
    public partial class serverForm : Form
    {
        public serverForm()
        {
            InitializeComponent();
        }
        
        Socket acceptUser;//连接客户端的socket实例
        Dictionary<string,Socket> userList = new Dictionary<string, Socket>();
        bool[] messType = { true, false, false };//默认用户要发送文字消息 [0]:发文字消息 [1]:发文件 [2]:发抖动窗口消息
        string sendFilePath;
        string fileName;
        /// <summary>
        /// 开始监听
        /// 1.创建socket对象
        /// 2.绑定IP和端口
        /// 3.设置监听队列
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void startListen_Click(object sender, EventArgs e)
        {
           //1.创建socket对象
            //参数1： 寻址方案：IP 4版本
            //参数2： 数据传输方式 以流的方式传输
            //参数3： 数据传输协议 TCP协议
           Socket serveSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

            //2.绑定IP和端口
           try
           {
               IPAddress severIP = IPAddress.Parse(showIPAdd.Text.ToString());
               IPEndPoint ipAndPor = new IPEndPoint(severIP, Convert.ToInt32(showPort.Text));
               serveSocket.Bind(ipAndPor);

               //3.设置监听队列

               serveSocket.Listen(10);
               loadSever();

               //开辟一个线程去等待用户连接
               Thread waitUserAccpet = new Thread(listen);
               waitUserAccpet.IsBackground = true;
               waitUserAccpet.Start(serveSocket);

               sendFile.Enabled = true;
               accepUsertList.Enabled = true;
               sendShake.Enabled = true;
               serveMessEdit.Enabled = true;
               serveSendMess.Enabled = true;
               startListen.Enabled = false;
           }
           catch 
           {
               serveShowMessge("IP地址或端口无效，请确认无误后在重试");
           }
                    
        }

        /// <summary>
        /// 显示整个过程需要显示的文本
        /// </summary>
        /// <param name="showMess"></param>
        private void serveShowMessge(string showMess)
        {
            showSeverLog.AppendText(showMess+"\r\n");
        }

        /// <summary>
        /// 因为不能让主线程去一直等待用户连接
        /// 新建一个线程专门负责去等待用户连接
        /// </summary>
        /// <param name="serveSock"></param>
        private void listen(object o)
        {
            Socket serveSocketMes = o as Socket;
            while (true)
            {
                try
                {
                    acceptUser = serveSocketMes.Accept();
                    serveShowMessge(acceptUser.RemoteEndPoint.ToString() + "：\t" + "连接成功");
                    userList.Add(acceptUser.RemoteEndPoint.ToString(), acceptUser);
                    accepUsertList.Items.Add(acceptUser.RemoteEndPoint.ToString());
                    Thread recevieUseerMes = new Thread(recevie);
                    recevieUseerMes.IsBackground = true;
                    recevieUseerMes.Start();
                }
                catch
                {

                }
              
            }
        }
        /// <summary>
        /// 程序加载时显示字符
        /// </summary>
        private void loadSever()
        {
            serveShowMessge("服务已启动");
            Thread.Sleep(1000);
            serveShowMessge("正在开启监听");
            Thread.Sleep(1000);
            serveShowMessge("监听成功等待用户连接");
        }

        /// <summary>
        /// 取消对跨线程访问的限制
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void serverForm_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
        }
        /// <summary>
        /// 接收客户端发送的消息
        /// </summary>
        /// <param name="serverSocke"></param>
        private void recevie()
        {
            byte[] recevieMessBuf = new byte[1024 * 1024 * 5];
            while (true)
            {
                try
                {
                    int recevieCountBy = acceptUser.Receive(recevieMessBuf);

                    if (recevieCountBy == 0)
                    {
                        serveShowMessge("对方可能已经下线了");
                        break;
                    }
                    MessageHandle(recevieMessBuf, recevieCountBy);
                }
                catch { }
            }
          
        }

        /// <summary>
        /// 给客户端发消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void serveSendMess_Click(object sender, EventArgs e)
        {
            SendMessHandle();
            messType[0] = true;
            messType[1] = false;
            messType[2] = false;
        }
        /// <summary>
        /// 发送消息处理
        /// </summary>
        private void SendMessHandle()
        {
            List<byte> messByte = new List<byte>();
            if (messType[0])
            {
                try
                {
                    messByte.Add(0);
                    messByte.AddRange(Encoding.Default.GetBytes(serveMessEdit.Text));
                    byte[] sendMessBuffer = messByte.ToArray();
                    userList[accepUsertList.SelectedItem.ToString()].Send(sendMessBuffer);
                    serveShowMessge("自己：" + serveMessEdit.Text);
                    serveMessEdit.Clear();
                }
                catch { }
               
            }
            else if (messType[1])
            {
                try
                {
                    //1.先发送文件名
                    messByte.Add(1);
                    messByte.AddRange(Encoding.Default.GetBytes(Path.GetFileName(sendFilePath)));

                    byte[] sendMessBuffer = messByte.ToArray();
                    userList[accepUsertList.SelectedItem.ToString()].Send(sendMessBuffer);
                    serveShowMessge("自己：" + Path.GetFileName(sendFilePath));

                    messByte.Clear();
                    //2.正式发送文件
                    messByte.Add(2);
                    using (FileStream readSendFile = new FileStream(sendFilePath, FileMode.Open, FileAccess.Read))
                    {
                        byte[] fileBuffer = new byte[1024 * 1024 * 4];
                        int readByCount = readSendFile.Read(fileBuffer, 0, fileBuffer.Length);
                        messByte.AddRange(fileBuffer);
                        messByte.RemoveRange(readByCount + 1, messByte.Count - readByCount - 1);
                        sendMessBuffer = messByte.ToArray();
                        userList[accepUsertList.SelectedItem.ToString()].Send(sendMessBuffer);
                    }
                }
                catch { }
               
            }
            else
            {
                try
                {
                    byte[] buffer = { 3 };
                    userList[accepUsertList.SelectedItem.ToString()].Send(buffer);
                    serveShowMessge("自己：\t给对方发了一个窗口抖动消息");
                }
                catch { }

            }
        }
        /// <summary>
        /// 用户需要发送文件
        /// 确定用户选择了文件后，传递用户选择的文件名
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void sendFile_Click(object sender, EventArgs e)
        {
            OpenFileDialog selectSendFile = new OpenFileDialog();
            selectSendFile.Title = "选择你要发送的文件";
            selectSendFile.Filter = "文本文件|*.txt|所有文件|*.*";
            selectSendFile.Multiselect = false;
            selectSendFile.ShowDialog();
            sendFilePath = selectSendFile.FileName;
            if (sendFilePath != "")
            {
                messType[0] = false;
                messType[1] = true;
                messType[2] = false;              
            }
        }
        /// <summary>
        /// 消息有很多类，所以根据缓冲字节数组的第一位鉴别是哪类消息
        /// [0]=0 代表接收的是文字消息
        /// [0]=1 代表接收的文件名消息
        /// [0]=2 代表接收到用文件的字节
        /// [0]=3 代表接收的时抖动窗口消息
        /// </summary>
        /// <param name="mesBuffer">接收其他用户发送的字节数组 </param>
        /// <param name="count">实际接收的字节个数</param>
        private void MessageHandle(byte[] mesBuffer,int count)
        {
            try
            {
                if (mesBuffer[0] == 0)
                {
                    string textMes = Encoding.Default.GetString(mesBuffer, 1, count - 1);
                    serveShowMessge(acceptUser.RemoteEndPoint.ToString() + "：\t" + textMes);
                }
                else if (mesBuffer[0] == 1)
                {
                    fileName = Encoding.Default.GetString(mesBuffer, 1, count - 1);
                    serveShowMessge(acceptUser.RemoteEndPoint.ToString() + "：\t" + fileName);
                }
                else if (mesBuffer[0] == 2)
                {
                    string fileFullPath = @"C:\Users\Administrator\Desktop\";
                    fileFullPath += fileName;
                    using (FileStream writeRecivevFile = new FileStream(fileFullPath, FileMode.Create, FileAccess.Write))
                    {
                        writeRecivevFile.Write(mesBuffer, 1, count - 1);
                    }
                    serveShowMessge(fileName + "接收成功");
                    fileName = null;
                }
                else
                {
                    formShake();
                    serveShowMessge(acceptUser.RemoteEndPoint.ToString() + "：\t" + "给你发了一个窗口抖动");

                }
            }
            catch { }
           
        }
        /// <summary>
        /// 抖动窗口
        /// </summary>
        private void formShake()
        {
            for (int i = 0; i < 500; i++)
            {
                this.Location = new Point(25, 100);
                this.Location = new Point(30, 100);
            }  
        }
        /// <summary>
        /// 窗口抖动消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void sendShake_Click(object sender, EventArgs e)
        {
            messType[0] = false;
            messType[1] = false;
            messType[2] = true;  
        }


    }
}
客户端

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 客户端
{
    public partial class userForm : Form
    {
        public userForm()
        {
            InitializeComponent();
        }
        Socket userSocket;
        string sendFilePath;
        string fileName;
        bool[] messType = { true, false, false };//默认用户要发送文字消息 [0]:发文字消息 [1]:发文件 [2]:发抖动窗口消息
        /// <summary>
        /// 客户端连接服务器
        /// 1.创建一个socket对象
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void connectServe_Click(object sender, EventArgs e)
        {
            //1.创建一个socket对象
             userSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            
            //用域名绑定IP
             //IPHostEntry hostInfo = Dns.GetHostEntry("19u232j797.51mypc.cn");
             //IPAddress ipAddress = hostInfo.AddressList[0]; 

            //2.连接服务器
            IPAddress serverIP = IPAddress.Parse(showUserIP.Text);
             userSocket.Connect(serverIP, Convert.ToInt32(showUserPort.Text));
            showUserMessage("连接成功");
            
            //启动发送消息的控件
            sendFile.Enabled = true;
            sendShakeMes.Enabled = true;
            userMesEdit.Enabled = true;
            userSendMes.Enabled = true;

             //接受客户端发送的消息
            Thread recevieServeMes = new Thread(recevie);
            recevieServeMes.IsBackground = true;
            recevieServeMes.Start();

            connectServe.Enabled = false;

        }
    
        /// <summary>
        /// 在整个过程中需要显示在消息日志上的字符
        /// </summary>
        /// <param name="userMessage"></param>
        private void showUserMessage(string userMessage)
        {
            showUserLog.AppendText(userMessage+"\r\n");
        }
        /// <summary>
        /// 接收服务端发送的消息
        /// </summary>
        private void recevie()
        {
            while (true)
            {
                try
                {
                    byte[] receServMesBuf = new byte[1024 * 1024 * 5];
                    int recevieCountBy = userSocket.Receive(receServMesBuf);
                    MessageHandle(receServMesBuf, recevieCountBy);
                }
                catch { }

            }
        }
        /// <summary>
        /// 客户端给服务器发消息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void userSendMes_Click(object sender, EventArgs e)
        {

            SendMessHandle();
            messType[0] = true;
            messType[1] = false;
            messType[2] = false;
        }

        /// <summary>
        /// 取消对跨线程的限制
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void userForm_Load(object sender, EventArgs e)
        {
            Control.CheckForIllegalCrossThreadCalls = false;
        }

        /// <summary>
        /// 发送文件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void sendFile_Click(object sender, EventArgs e)
        {
            OpenFileDialog selectSendFile = new OpenFileDialog();
            selectSendFile.Title = "选择你要发送的文件";
            selectSendFile.Filter = "文本文件|*.txt|所有文件|*.*";
            selectSendFile.Multiselect = false;
            selectSendFile.ShowDialog();
            sendFilePath = selectSendFile.FileName;
            if (sendFilePath != "")
            {
                messType[0] = false;
                messType[1] = true;
                messType[2] = false;
            }
        }
        /// <summary>
        /// 发送消息处理
        /// </summary>
        private void SendMessHandle()
        {
            List<byte> messByte = new List<byte>();
            if (messType[0])
            {
                try
                {
                    messByte.Add(0);
                    messByte.AddRange(Encoding.Default.GetBytes(userMesEdit.Text));
                    byte[] sendMessBuffer = messByte.ToArray();
                    userSocket.Send(sendMessBuffer);
                    showUserMessage("自己：" + userMesEdit.Text);
                    userMesEdit.Clear();
                }
                catch { }
               
            }
            else if (messType[1])
            {
                try
                {
                    //1.先发送文件名
                    messByte.Add(1);
                    messByte.AddRange(Encoding.Default.GetBytes(Path.GetFileName(sendFilePath)));

                    byte[] sendMessBuffer = messByte.ToArray();
                    userSocket.Send(sendMessBuffer);
                    showUserMessage("自己：" + Path.GetFileName(sendFilePath));

                    messByte.Clear();
                    //2.正式发送文件
                    messByte.Add(2);
                    using (FileStream readSendFile = new FileStream(sendFilePath, FileMode.Open, FileAccess.Read))
                    {
                        byte[] fileBuffer = new byte[1024 * 1024 * 4];
                        int readByCount = readSendFile.Read(fileBuffer, 0, fileBuffer.Length);
                        messByte.AddRange(fileBuffer);
                        messByte.RemoveRange(readByCount + 1, messByte.Count - readByCount - 1);
                        sendMessBuffer = messByte.ToArray();
                        userSocket.Send(sendMessBuffer);
                    }
                }
                catch { }

            }
            else
            {
                try
                {
                    byte[] buffer = { 3 };
                    userSocket.Send(buffer);
                    showUserMessage("自己：\t给对方发了一个窗口抖动消息");
                }
                catch { }

            }
        }

        /// <summary>
        /// 消息有很多类，所以根据缓冲字节数组的第一位鉴别是哪类消息
        /// [0]=0 代表接收的是文字消息
        /// [0]=1 代表接收的文件名消息
        /// [0]=2 代表接收到用文件的字节
        /// [0]=3 代表接收的时抖动窗口消息
        /// </summary>
        /// <param name="mesBuffer">接收其他用户发送的字节数组 </param>
        /// <param name="count">实际接收的字节个数</param>
        private void MessageHandle(byte[] mesBuffer, int count)
        {
            try
            {
                if (mesBuffer[0] == 0)
                {
                    string textMes = Encoding.Default.GetString(mesBuffer, 1, count - 1);
                    showUserMessage(userSocket.RemoteEndPoint.ToString() + "：\t" + textMes);
                }
                else if (mesBuffer[0] == 1)
                {
                    fileName = Encoding.Default.GetString(mesBuffer, 1, count - 1);
                    showUserMessage(userSocket.RemoteEndPoint.ToString() + "：\t" + fileName);
                }
                else if (mesBuffer[0] == 2)
                {
                    string fileFullPath = @"C:\Users\Administrator\Desktop\";
                    fileFullPath += fileName;
                    using (FileStream writeRecivevFile = new FileStream(fileFullPath, FileMode.Create, FileAccess.Write))
                    {
                        writeRecivevFile.Write(mesBuffer, 1, count - 1);
                    }
                    showUserMessage(fileName + "接收成功");
                    fileName = null;
                }
                else
                {
                    formShake();
                    showUserMessage(userSocket.RemoteEndPoint.ToString() + "：\t" + "给你发了一个窗口抖动");

                }
            }
            catch { }
         
        }

        /// <summary>
        /// 抖动窗口
        /// </summary>
        private void formShake()
        {
            for (int i = 0; i < 500; i++)
            {
                this.Location = new Point(25, 100);
                this.Location = new Point(30, 100);
            }
        }

        private void sendShakeMes_Click(object sender, EventArgs e)
        {
            messType[0] = false;
            messType[1] = false;
            messType[2] = true;
        }

    }
}
 

转载于:https://my.oschina.net/u/3026393/blog/1592674

chengren2016
关注
C# Socket通讯
10-28
C# Socket通讯 转载的， VS2008可用
C#中简单Socket编程
最新发布
weixin_45144862的博客
07-09 1445
TCP通信服务端的通信过程是：第一步调用Socket创建套接字。第二步：调用Bind()函数将套接字绑定到指定的IP地址和端口号。第三步：调用Listen()函数监听套接字。Socket分为面向连接的套接字(TCP套接字)和面向消息的套接字(UDP 套接字)。客户端套接字通信过程是：第一步:调用Socket类创建套接字。第一步：创建套接字。第一步：创建套接字。第二步：将套接字绑定到指定IP地址和端口号。UDP通信是面向消息的通信方式。接下来，我用C#语言来进行简单的TCP通信和UDP通信。
C# Socket通信客户端类、服务器类
weixin_34409822的博客
11-28 285
         其实这些东西网上都有，但是比较凌乱，很少有封装好的类，在此共享一下。。。          一个Socket服务器类，一个Socket客户端类，都可以直接拿去用，下边有详细的调用示例。          需要说明的是，服务器类没有处理多客户连接，只是简单的响应单客户连接。          另外，提醒一点，尤其是很多新手容易犯的错误，就是服务器类处理事务是在线程中进行的，此...
C# 基于Socket的网络通信类
IT技术猿猴的博客
03-27 1550
基于Socket的网络处理类
C# socket通信
weixin_41047135的博客
06-19 534
关于C#socket通信，分为同步和异步通信，本文简单介绍一下同步通信。通信两端分别为客户端（Client）和服务器(Server):(1)Cient:1：建立一个Socket对像；2：用socket对像的Connect()方法以上面建立的EndPoint对像做为参数，向服务器发出连接请求；3：如果连接成功，就用socket对像的Send()方法向服务器发送信息；4：用socket对像的Recei...
C# Socket通信（winform） 异步发送消息，服务端客户端通信，可以发送消息和文件并进行接收
06-13
C# Socket通信（winform） 异步发送消息，服务端客户端通信，可以发送消息和文件并进行接收，代码注释详细 C# Socket通信（winform） 异步发送消息，服务端客户端通信，可以发送消息和文件并进行接收，代码注释详细 ...
C# Socket 通信，客户端服务器端
03-30
本教程将深入讲解C#中的Socket通信，包括客户端和服务器端的实现，以及如何通过源码学习相关知识。 首先，我们要理解Socket的基本概念。Socket，也称为套接字，是网络通信中的一个接口，它允许应用程序通过网络发送...
C# socket通信项目，实现了实现了心跳、断线重连、服务端异步接收数据、消息回调反馈、解决了粘包相关问题，可以多客户端
06-13
C# socket通信（免积分下载），本项目有三个部分：1、客户端（winform）；2、服务端（winform）；3、socket功能类库模块（其他项目也可以引用），socket类库模块功能齐全，只需调用其中方法即可，复用性较强，代码...
C#Socket通信稳定完整版类库实例
03-26
Socket通信在IT行业中是网络编程的基础，特别是在C#这样的多平台开发环境中，Socket通信库的使用至关重要。本实例，"C# Socket通信稳定完整版类库实例"，为我们提供了一个全面且稳定的解决方案，用于实现客户端与...
手把手教你从入门到精通C# Socket通信
qq_34059233的博客
01-17 4793
本文以我开发的TCP/UDP调试助手为例，详细介绍《C#Socket通信从入门到精通》专栏的目录内容，本专栏由一个高级工程师多年实战经验总结，绝对是C# TCP/UDP通信的葵花宝典！带您从入门到精通C#TCP/UDP通信！
一封装过的C#Socket通讯类
03-11
封装了C#里的socket,我自己用的，尤其是UDP通讯时，我觉得很方便
C#实现socket通讯
03-08
WPF实现CS结构，基于socket连接，实现ServerClient发送消息
c#Socket通信
weixin_30698297的博客
03-11 91
网络通信的基本知识： 首先应该确定IP地址和端口号，端口号为了确定计算机的哪个进程，比如同一主机是微信还是qq通信 要进行通信首先应该确定一种协议，通常用TCP可靠和UDP不可靠协议，当然带来的速度也会不同，多数游戏中采用TCP协议。 面向连接套接字通信步骤： 服务端： 先申请一个Socket，绑定一个IP地址和端口，开始接听，等待接受连接。 客户端： 申请一个Socket，连...
Socket通信例子
weixin_30794491的博客
01-23 290
Server端 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; ...
C# Socket通信 转自博客园
hutao1101175783的专栏
07-15 2594
Server代码 using System; using System.Collections.Generic; using System.Linq; using System.Text; //添加Socket类 using System.Net; using System.Net.Sockets; namespace SockeConsoleServer { c
C#的Socket通讯
weixin_43493709的博客
04-15 7225
１.Socket简介 Socket：称”套接字”，套接字(socket)是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。应用程序通过”套接字”向网络发送请求或应答，它是一个针对TCP和UDP编程的接口，借助它建立TCP/UDP连接。创建Socket连接时，可以指定使用传输层协议(TCP或UDP)，当使用TCP协议进行连接时，该Socket连接就是一个TCP连接。当使用UDP协议进行连...
C#Socket通讯
LonelyBHBH的博客
11-22 615
Socket通讯 多台计算机想要建立起连接就要通过这个Socket来连接，socket可以理解成程序间的电话 原来的意思就是孔或者插座 通讯就要分为客户端和服务端 打个比方 客户端就是男生，服务端就是女生，男生要去找女生就要经过一个宿管大妈，而这个宿管大妈就是负责监听的socket 我客户端想要询问服务端的里面的东西就要知道IP和端口号 IP就是访问到指定的服务端，而端口号就是指定的服务端里面的各种各样的app，而宿管大妈就是负责监视，来的客户，把他分配给客户想要的女生也就是app。让app和男生接触。
C# Socket通信
lvxingzhe3的博客
12-12 2531
Socket客户端和服务端通信
C# socket通信
09-08
C# socket通信是通过编程实现计算机之间的数据交互技术。Socket翻译成中文就是"套接字"，它是计算机网络编程中的一个概念，用于实现网络通信。在C#中，可以使用Socket类来创建socket客户端和服务端，实现两台或多台...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值