C#的TCP的及时通信DEMO

最新推荐文章于 2024-10-12 21:57:24 发布
最新推荐文章于 2024-10-12 21:57:24 发布
阅读量506 收藏 3
点赞数
分类专栏： 默认 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43542114/article/details/107509260
版权

闲来没事写一个C#的TCP的及时通信，可以在不同的相同机器上运行：全部代码如下

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Net.Sockets;
using System.Diagnostics;
using System.Net;
using System.Text.RegularExpressions;
using System.IO;
using System.Net.NetworkInformation;
using System.Xml.Serialization;

namespace SocketText
{
    public partial class FrmText : Form
    {
        #region Var
        public delegate void OperalControl();
        private Thread ProcWorkThread = null;
        private Thread FlushThread = null;
        private bool FlushThreadIsLoop = false;
        private int FlushSleepTime = int.MinValue;
        private TcpListener ServerListener = null;
        private char SplitChar = '^';
        private IPAddress MyAddress = null;
        private List<string> LocalHostIPList;
        private int IPListIndex = 0;
        private int LocalHostPort = int.MinValue;
        private byte[] CacheBuffer = new byte[1024];
        private int CacheBufferLength = 0;
        private bool IsloopFlag = false;
        private bool ISTrigSendEvent = false;
        private System.Windows.Forms.Timer FlushTimer = new System.Windows.Forms.Timer();
        private string SaveUserInfoPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "user.xml");
        private int IndexIP = int.MinValue;
        private int IndexPort = int.MinValue;
        private int IndexIsOnline = int.MinValue;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public FrmText()
        {
            InitializeComponent();
            ColumnHeader IP = new ColumnHeader();
            IP.Width = 150;
            IP.Name = "IP";
            IP.Text = "IP地址";
            ColumnHeader Port = new ColumnHeader();
            Port.Width = 100;
            Port.Name = "Port";
            Port.Text = "端口号";
            ColumnHeader IsOnline = new ColumnHeader();
            IsOnline.Name = "IsOnline";
            IsOnline.Text = "是否在线";
            IsOnline.Width = 100;
            listViewFriend.View = View.Details;
            listViewFriend.Columns.AddRange(new ColumnHeader[] { IP, Port, IsOnline });
            LocalHostIPList = GetClientIPAddress();
            Debug.Assert(LocalHostIPList.Count > 0, "获取本地IP地址失败！");
            //获取各个列的索引值 提供给subitems用
            IndexIP = listViewFriend.Columns["IP"].Index;
            IndexPort = listViewFriend.Columns["Port"].Index;
            IndexIsOnline = listViewFriend.Columns["IsOnline"].Index;

        }




        /// <summary>
        /// 窗体加载事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FrmText_Load(object sender, EventArgs e)
        {
            FlushTimer.Tick += new EventHandler(FlushTimer_Tick);
            txtLocalIP.Enabled = false;
            IsloopFlag = true;

            //读取用户信息
            if (File.Exists(SaveUserInfoPath))
            {
                object userInfo = DeserializeXmL(SaveUserInfoPath, typeof(List<ClientNetINfo>));
                List<ClientNetINfo> userInfoList = userInfo as List<ClientNetINfo>;
                if (userInfoList != null)
                {
                    LocalHostPort = int.Parse(userInfoList[0].Port);
                    for (int indx = 1; indx < userInfoList.Count; indx++)
                    {
                        ListViewItem item = new ListViewItem(new string[] { userInfoList[indx].IP, userInfoList[indx].Port, "未知" });
                        item.UseItemStyleForSubItems = false;
                        item.SubItems[IndexIsOnline].ForeColor = Color.Gray;
                        item.Name = userInfoList[indx].IP + userInfoList[indx].Port;
                        listViewFriend.Items.Add(item);
                        if (!txtFriendIP.Items.Contains(userInfoList[indx].IP))
                        {
                            txtFriendIP.Items.Add(userInfoList[indx].IP);
                        }

                    }
                }
            }
            ProcWorkThread = new Thread(ListenClient);
            ProcWorkThread.IsBackground = true;
            ProcWorkThread.Start();

            //Thread GetAllIP = new Thread(GetAreaAllIP);
            //GetAllIP.IsBackground = true;
            //GetAllIP.Start();
        }

        void GetAreaAllIP()
        {
            List<string> listIPs = GetLocalAreaOnlineIPs();
            OperaControl(txtFriendIP, () => { txtFriendIP.DataSource = listIPs; });

        }

        /// <summary>
        /// 定时器出发事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void FlushTimer_Tick(object sender, EventArgs e)
        {
            foreach (ListViewItem item in listViewFriend.Items)
            {
                bool ret = SendData(InfoEnum.CheckISOnline, "检测是否在线", item.SubItems[IndexIP].Text, item.SubItems[IndexPort].Text);
                OperatelistViewFriend(InfoEnum.CheckISOnline, item.SubItems[IndexIP].Text, item.SubItems[IndexPort].Text, ret);
            }
        }

        /// <summary>
        /// 监听线程  来监听客户端连接  
        /// </summary>
        private void ListenClient()
        {

            Socket clientSocket = null;
            Random random = new Random();
            MyAddress = IPAddress.Parse(LocalHostIPList[IPListIndex]);
            while (IsloopFlag)
            {
                //LocalHostPort = int.Parse(txtLocalPort.Text);

                if (LocalHostPort < 0)
                {
                    LocalHostPort = random.Next(0, 65535);
                }
                try
                {
                    ServerListener = new TcpListener(MyAddress, LocalHostPort);
                    ServerListener.Start(3);
                }
                catch (Exception ex)
                {
                    AddlistViewMsg(string.Format("监听IP:{0} 端口:{1}失败！Msg:{2}。", this.MyAddress.ToString(), LocalHostPort.ToString(), ex.Message));
                    LocalHostPort = random.Next(0, 65535);
                    continue;
                }

                OperaControl(txtLocalIP, () => { txtLocalIP.Text = MyAddress.ToString(); });
                OperaControl(txtLocalPort, () => { txtLocalPort.Text = LocalHostPort.ToString(); });
                AddlistViewMsg(string.Format("监听IP:{0}[{1}]成功。", this.MyAddress.ToString(), LocalHostPort.ToString()));
                break;
            }
            while (IsloopFlag)
            {
                try
                {
                    clientSocket = ServerListener.AcceptSocket();
                    //获取得到
                    //ThreadPool.QueueUserWorkItem(ReciveClient, clientSocket);
                    clientSocket.ReceiveTimeout = 3000;
                    CacheBufferLength = clientSocket.Receive(CacheBuffer);
                    ShowReciveBuffer(Encoding.UTF8.GetString(CacheBuffer, 0, CacheBufferLength));
                    //完成信息传递后必须断开连接 否则会在成服务端大量客服端连接 
                    clientSocket.Close(5);
                }
                catch (Exception ex)
                {

                    if (clientSocket != null)
                    {
                        clientSocket.Close(5);
                    }
                    if (IsloopFlag)
                    {
                        AddlistViewMsg("错误异常" + ex.Message);
                        continue;
                    }
                    else
                    {
                        break;
                    }

                    //ProcWorkThread.Abort();
                    //throw;
                }
            }
        }

        private void ShowReciveBuffer(string recStr)
        {
            int splitCharNu = recStr.Length - (recStr.Replace(SplitChar.ToString(), "").Length);
            if (splitCharNu != 3)
            {
                AddlistViewMsg(" 收到非法数据: " + recStr);
                return;
            }
            string[] recStrArray = recStr.Split(SplitChar);
            InfoEnum infoType = (InfoEnum)(int.Parse(recStrArray[0]));

            switch (infoType)
            {
                case InfoEnum.Unknown:
                    break;
                case InfoEnum.AddFriend:
                    OperatelistViewFriend(InfoEnum.AddFriend, recStrArray[1].ToString(), recStrArray[2].ToString());
                    AddlistViewMsg(string.Format(" 添加好友: {0}[{1}] ", recStrArray[1], recStrArray[2]));
                    break;
                case InfoEnum.CheckISOnline:
                    OperatelistViewFriend(InfoEnum.CheckISOnline, recStrArray[1].ToString(), recStrArray[2].ToString());
                    //AddlistViewMsg(string.Format(" 上线了{0}:{1} (*￣︶￣)", recStrArray[1], recStrArray[2]));
                    break;
                case InfoEnum.Messages:
                    AddlistViewMsg(string.Format(" 接收到{0}[{1}]的信息: {2}", recStrArray[1], recStrArray[2], recStrArray[3]));
                    break;
                case InfoEnum.DeleteFriend:
                    OperatelistViewFriend(InfoEnum.DeleteFriend, recStrArray[1].ToString(), recStrArray[2].ToString());
                    AddlistViewMsg(string.Format(" 删除了好友: {0}[{1}] ", recStrArray[1], recStrArray[2]));
                    break;
                default:
                    break;
            }

        }

        /// <summary>
        /// 客户端不停接收数据 此链接无需维护
        /// </summary>
        /// <param name="cliSocket"></param>
        void ReciveClient(object cliSocket)
        {
            Socket client = cliSocket as Socket;
            if (client != null)
            {
                while (IsloopFlag)
                {
                    try
                    {
                        EndPoint ipEnd = new IPEndPoint(IPAddress.Any, 0);
                        byte[] buffer = new byte[1024];
                        //阻塞模式接收数据
                        int recNu = client.ReceiveFrom(buffer, ref ipEnd);
                        if (recNu == 0)
                        {
                            //客户端异常退出
                        }


                    }
                    catch (Exception)
                    {
                        //客户端异常退出

                        break;
                        //throw;
                    }
                }
            }
        }



        /// <summary>
        /// 获取本机的默认IP地址
        /// </summary>
        /// <returns></returns>
        private List<string> GetClientIPAddress()
        {
            List<string> listIP = new List<string>();
            try
            {
                IPAddress[] addressArray = Dns.GetHostAddresses(Dns.GetHostName());
                Regex regex = new Regex(@"\b(([01]?\d?\d|2[0-4]\d|25[0-5])\.){3}([01]?\d?\d|2[0-4]\d|25[0-5])\b");
                foreach (IPAddress itemStr in addressArray)
                {
                    if (regex.IsMatch(itemStr.ToString(), 0) && listIP.Contains(itemStr.ToString()) == false)
                    {
                        listIP.Add(itemStr.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                AddlistViewMsg("获取本地IP地址，错误信息" + ex.Message);
                //throw;
            }

            return listIP;
        }

        /// <summary>
        /// 操作方法
        /// </summary>
        /// <param name="contr">控件 </param>
        /// <param name="funcMethod">操作委托</param>
        private void OperaControl(Control contr, OperalControl funcMethod)
        {
            if (contr.InvokeRequired)
            {
                contr.Invoke(funcMethod, null);
            }
            else
            {
                funcMethod();
            }
        }

        private void AddlistViewMsg(string msgStr)
        {
            OperaControl(listViewMsg, () => { listViewMsg.AppendText(string.Format("\r\n*{0:HH时MM分ss秒}* {1}\r\n", DateTime.Now, msgStr)); });
        }


        private void OperatelistViewFriend(InfoEnum operaTpye, string IP, string port, bool IsOnline = true)
        {
            if (operaTpye == InfoEnum.AddFriend)
            {
                OperaControl(listViewFriend, () =>
                   {
                       if (!listViewFriend.Items.ContainsKey(IP + port))
                       {

                           ListViewItem curViewItem = new ListViewItem(new string[] { IP, port, "在线" });
                           curViewItem.UseItemStyleForSubItems = false;
                           curViewItem.SubItems[IndexIsOnline].ForeColor = Color.Green;
                           curViewItem.Name = IP + port;
                           listViewFriend.Items.Add(curViewItem);
                       }
                   });
            }
            else if (operaTpye == InfoEnum.CheckISOnline)
            {

                OperaControl(listViewFriend, () =>
                {
                    listViewFriend.BeginUpdate();
                    foreach (ListViewItem item in listViewFriend.Items)
                    {
                        if (item.Name == IP + port)
                        {
                            if (IsOnline)
                            {
                                item.SubItems[IndexIsOnline].Text = "在线";
                                item.SubItems[IndexIsOnline].ForeColor = Color.Green;
                            }
                            else
                            {
                                item.SubItems[IndexIsOnline].Text = "离线";
                                item.SubItems[IndexIsOnline].ForeColor = Color.Red;
                            }

                            break;
                        }
                    }
                    //listViewFriend.Refresh();
                    listViewFriend.EndUpdate();
                });
            }
            else if (operaTpye == InfoEnum.DeleteFriend)
            {
                OperaControl(listViewFriend, () =>
                {
                    foreach (ListViewItem item in listViewFriend.Items)
                    {
                        if (item.Name == IP + port)
                        {
                            listViewFriend.Items.Remove(item);
                            break;
                        }
                    }
                });
            }

        }

        /// <summary>
        /// 添加好友
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAddFriend_Click(object sender, EventArgs e)
        {

            if (txtLocalIP.Text == txtFriendIP.Text && txtFriendPort.Text == txtLocalPort.Text)
            {
                MessageBox.Show("不能添加自己为好友！");
                return;
            }
            bool addFriendRet = SendData(InfoEnum.AddFriend, "添加好友", txtFriendIP.Text, txtFriendPort.Text);
            if (addFriendRet)
            {
                OperatelistViewFriend(InfoEnum.AddFriend, txtFriendIP.Text, txtFriendPort.Text);
                AddlistViewMsg(string.Format(" 添加好友成功 {0}[{1}]", txtFriendIP.Text, txtFriendPort.Text));
            }
            else
            {
                MessageBox.Show("添加好友失败！");
            }
        }


        private bool SendData(InfoEnum operalType, string SendStr, string serverIP, string serverPort)
        {
            bool retSend = false;
            byte[] sendBytes = Encoding.UTF8.GetBytes(string.Format("{0}{1}{2}{1}{3}{1}{4}", (int)operalType, SplitChar, MyAddress.ToString(), LocalHostPort, SendStr));
           //添加判断如果不是同一个网段直接返回false
            if (serverIP.Remove(serverIP.LastIndexOf('.'))!=MyAddress.ToString().Remove(MyAddress.ToString().LastIndexOf('.')))
            {
                return retSend;
            }
            try
            {
                IPEndPoint serverIEP = new IPEndPoint(IPAddress.Parse(serverIP), int.Parse(serverPort));
                TcpClient client = new TcpClient(new IPEndPoint(MyAddress, 0));
                client.Connect(serverIEP);
                client.Client.Send(sendBytes);
                retSend = true;
                client.Close();
            }
            catch (Exception)
            {
                return retSend;
            }
            return retSend;
        }

        /// <summary>
        /// 发送消息事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void txtSendMsg_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Control && e.KeyCode == Keys.Return)
            {
                ISTrigSendEvent = true;
                if (listViewFriend.CheckedItems.Count <= 0)
                {
                    MessageBox.Show("请先选择好友！");
                }
                else if (txtSendMsg.Text.Length <= 0)
                {
                    MessageBox.Show("请输入发送信息！");
                }
                else
                {
                    foreach (ListViewItem item in listViewFriend.CheckedItems)
                    {
                        bool ret = SendData(InfoEnum.Messages, txtSendMsg.Text, item.SubItems[IndexIP].Text, item.SubItems[IndexPort].Text);
                        if (!ret)
                        {
                            //发送信息失败  好友下线
                            OperatelistViewFriend(InfoEnum.CheckISOnline, item.SubItems[IndexIP].Text, item.SubItems[IndexPort].Text, false);
                            MessageBox.Show(string.Format("发送给{0}:{1}送消息失败，好友已经下线！", item.SubItems[IndexIP].Text, item.SubItems[IndexPort].Text));
                        }
                        else
                        {
                            //更新好友状态 在线
                            OperatelistViewFriend(InfoEnum.CheckISOnline, item.SubItems[IndexIP].Text, item.SubItems[IndexPort].Text, true);
                            AddlistViewMsg(string.Format("发送{0}[{1}]消息:{2}", item.SubItems[IndexIP].Text, item.SubItems[IndexPort].Text, txtSendMsg.Text));
                        }
                    }
                }
            }
        }

        private void txtSendMsg_TextChanged(object sender, EventArgs e)
        {
            if (ISTrigSendEvent)
            {
                txtSendMsg.Text = txtSendMsg.Text.TrimEnd(new char[] { '\r', '\n' });
                ISTrigSendEvent = false;
                txtSendMsg.Select(txtSendMsg.Text.Length, 0);
            }
        }

        /// <summary>
        /// 启动刷新好友
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnFlushOnline_Click(object sender, EventArgs e)
        {
            int timerVal;
            bool retTrybool = int.TryParse(txtFlushTime.Text, out timerVal);
            if (!retTrybool)
            {
                MessageBox.Show("输入定时刷新时间无效！");
                return;
            }
            FlushSleepTime = timerVal;
            FlushThreadIsLoop = true;
            FlushThread = new Thread(FlushFriendOnline);
            FlushThread.IsBackground = true;
            FlushThread.Start();


            btnFlushOnline.Enabled = false;
        }

        /// <summary>
        /// 线程刷新好友是否在线
        /// </summary>
        void FlushFriendOnline()
        {
            while (FlushThreadIsLoop)
            {
                List<ClientNetINfo> tempList = new List<ClientNetINfo>();
                OperaControl(listViewFriend, () =>
                {
                    foreach (ListViewItem item in listViewFriend.Items)
                    {
                        ClientNetINfo entity = new ClientNetINfo();
                        entity.IP = item.SubItems[IndexIP].Text;
                        entity.Port = item.SubItems[IndexPort].Text;
                        tempList.Add(entity);
                    }
                });
                foreach (ClientNetINfo item in tempList)
                {
                    bool ret = SendData(InfoEnum.CheckISOnline, "检测是否在线", item.IP, item.Port);
                    OperatelistViewFriend(InfoEnum.CheckISOnline, item.IP, item.Port, ret);
                }

                Thread.Sleep(FlushSleepTime);
            }
        }

        private void btnStopFlushOnline_Click(object sender, EventArgs e)
        {
            FlushThreadIsLoop = false;
            if (FlushThread != null && FlushThread.IsAlive)
            {
                FlushThread.Abort();
            }

            btnFlushOnline.Enabled = true;
        }

        private void ChangeLocalIPList()
        {
            if (IPListIndex < LocalHostIPList.Count - 1)
            {
                IPListIndex++;
            }
            else
            {
                IPListIndex = 0;
            }

        }

        /// <summary>
        /// 切换本地IP地址
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSwitchIP_Click(object sender, EventArgs e)
        {
            ChangeLocalIPList();
            IsloopFlag = false;
            if (ServerListener != null)
            {
                ServerListener.Stop();
            }
            ProcWorkThread.Abort();
            ServerListener = null;
            AddlistViewMsg(string.Format("{0}:{1}退出监听", txtLocalIP.Text, txtLocalPort.Text));
            Thread.Sleep(10);
            //开启监听
            if (LocalHostPort.ToString() != txtLocalPort.Text)
            {
                LocalHostPort = int.Parse(txtLocalPort.Text);
            }
            IsloopFlag = true;
            ProcWorkThread = new Thread(ListenClient);
            ProcWorkThread.IsBackground = true;
            ProcWorkThread.Start();

        }

        private List<string> GetLocalAreaOnlineIPs()
        {
            List<string> IPList = new List<string>();
            IPAddress[] localhostIPs = Dns.GetHostAddresses(Dns.GetHostName()).Where<IPAddress>(ret => ret.AddressFamily.ToString() == "InterNetwork").ToArray();
            string localIPStr = string.Empty;
            Ping textPing = new Ping();
            PingReply pingReply = null;
            byte[] data = { 0 };
            foreach (IPAddress itemIPstr in localhostIPs)
            {
                localIPStr = itemIPstr.ToString();
                //截取IP网段
                string IPSegment = localIPStr.Remove(localIPStr.LastIndexOf('.'));
                for (int idx = 1; idx < 255; idx++)
                {
                    string pingIP = IPSegment + "." + idx;
                    pingReply = textPing.Send(pingIP, 5, data);

                    if (pingReply.Status == IPStatus.Success)
                    {
                        IPList.Add(pingIP);
                    }
                }

            }
            return IPList;
        }


        /// <summary>
        ///保存好友信息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void FrmText_FormClosing(object sender, FormClosingEventArgs e)
        {
            List<ClientNetINfo> tempList = new List<ClientNetINfo>();
            tempList.Add(new ClientNetINfo() { IP = txtLocalIP.Text, Port = txtLocalPort.Text });
            foreach (ListViewItem item in listViewFriend.Items)
            {
                ClientNetINfo entity = new ClientNetINfo();
                entity.IP = item.SubItems[IndexIP].Text;
                entity.Port = item.SubItems[IndexPort].Text;
                tempList.Add(entity);
            }
            //xml 序列化
            SerializeToXMl(SaveUserInfoPath, tempList);
        }

        /// <summary>
        /// XML序列化
        /// </summary>
        /// <param name="path"></param>
        /// <param name="obj"></param>
        private void SerializeToXMl(string path, object obj)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(obj.GetType());
            string strSerial = string.Empty;
            using (StringWriter strWriter = new StringWriter())
            {
                xmlSerializer.Serialize(strWriter, obj);
                strSerial = strWriter.ToString();
            }
            string rexStr = Convert.ToBase64String(Encoding.UTF8.GetBytes(strSerial));
            using (StreamWriter write = new StreamWriter(path))
            {
                write.Write(rexStr);
            }
        }

        /// <summary>
        /// XML反序列化
        /// </summary>
        /// <param name="path"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private object DeserializeXmL(string path, Type type)
        {
            XmlSerializer deSerial = new XmlSerializer(type);
            string readStr = string.Empty;
            using (StreamReader reader = new StreamReader(path, Encoding.UTF8))
            {
                readStr = reader.ReadToEnd();
            }
            byte[] readByte = Convert.FromBase64String(readStr);
            MemoryStream MemoStream = new MemoryStream(readByte);
            using (StreamReader readerEnd = new StreamReader(MemoStream, Encoding.UTF8))
            {
                return deSerial.Deserialize(readerEnd);
            }

        }
        //右键删除好友
        private void DeleteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (listViewFriend.SelectedItems.Count != 1)
            {
                MessageBox.Show("请先选择删除的好友！");
                return;
            }
            DialogResult result = MessageBox.Show("确认要删除好友吗？", "删除好友", MessageBoxButtons.OKCancel);
            if (result == DialogResult.OK)
            {
                ListViewItem livs = listViewFriend.SelectedItems[0];
                string ipStr=livs.SubItems[IndexIP].Text;
                string PortStr=livs.SubItems[IndexPort].Text;
                bool retDel = SendData(InfoEnum.DeleteFriend, "把你删除了",ipStr ,PortStr );
                if (retDel)
                {
                    //删除成功
                    OperatelistViewFriend(InfoEnum.DeleteFriend, ipStr, PortStr);
                    AddlistViewMsg(string.Format(" 主动删除好友{0}[{1}]成功!", ipStr, PortStr));
                }
                else
                {
                    //删除失败
                    OperatelistViewFriend(InfoEnum.CheckISOnline, ipStr, PortStr,false);
                    MessageBox.Show("删除好友失败！");
                }
            }
        }

        //复制端口号
        private void CopyPortToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (listViewFriend.SelectedItems.Count != 1)
            {
                MessageBox.Show("请先选择要复制的端口号！");
                return;
            }
            ListViewItem livs = listViewFriend.SelectedItems[0];
            Clipboard.SetText(livs.SubItems[IndexPort].Text);
        }




    }

    public enum InfoEnum
    {
        Unknown = 0,
        AddFriend = 1,
        CheckISOnline = 2,
        Messages = 3,
        DeleteFriend = 4,
    }
    public class ClientNetINfo
    {
        public string IP { get; set; }
        public string Port { get; set; }
    }
}

加粗样式在这里插入图片描述
完整示例下载链接：https://download.csdn.net/download/weixin_43542114/12651028

望天hous
关注
专栏目录
C# 与 Socket 编程：创建即时通讯客户端
java专栏
08-30 775
Socket 是一种在不同计算机之间进行通信的方法。你可以把它想象成互联网上的邮递员，负责在两台电脑之间传递消息。在 C# 中，我们使用命名空间提供的类来实现 Socket 编程。
C# 网络编程之socket tcp 通讯demo样例
06-05
本人通过网络搜索，搜索到的一个感觉蛮不错的socket通讯demo示例。希望对想学习C#网络编程的朋友有所帮助！ 对于想开发网络通讯程序的朋友具有不错的参考价值！
TCP Server/Client Demo C#程序
08-29
TCP Server/Client Demo 程序，实现基本的通信测试，C#编程
TCP Server/Client Demo C程序
最新发布
gitblog_09739的博客
10-12 303
TCP Server/Client Demo C#程序 TCPServerClientDemoC程序 本仓库提供了一个简单的TCP Server/Client Demo程序，使用C#语言编写。该程序旨在帮助开发者理解和实现基本的TCP通信功能，适用于学习和测试目的 ...
C#下使用TCP通讯Demo
Stay hungry,stay foolish
08-14 1589
Demo分成两部分第一部分是Server端 第二部分是Client端 首先是Server端代码： using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Text; using System
c#基于TCP协议的Socket通信完整Demo（已实现多人聊天室）
11-17
c#基于TCP协议的Socket通信完整实例（实现多人聊天室），通过C#winform实现多人聊天，同时服务器可以向指定客户端发送消息
C#TCP通讯DEMO
12-17
A控制B，那A就是上位机，A发送协议内规定的一串数据，B接收到确认数据没错再返回其对应的数据。相对应的B就是下位机，plc常见的上位机有pc，HMI，其他plc，与pc通讯
C# 简单Tcp通信demo
02-17 519
Client 代码 private void btnSend_Click(object sender, EventArgs e) { TcpClient tcpClient = new TcpClient(txthost.Text, Int32.Parse(txtport.Text)); //创建tcp客户端 NetworkS...
Demo_Apps.zip_DEMO_c# TCP工具
09-24
标题中的“Demo_Apps.zip_DEMO_c# TCP工具”表明这是一个使用C#编程语言开发的TCP/IP通信示例应用程序。这个应用可能是一个简单的网络聊天工具，功能类似于我们常见的即时通讯软件“message”，允许用户通过TCP/IP...
C# Winform 即时通信实例（基于Socket ）
03-18
本项目“C# Winform 即时通信实例（基于Socket）”提供了一个使用C#编程语言和Windows Forms（Winform）界面设计工具创建的简单即时通信系统。这个系统的核心是Socket编程，它是网络通信的基础，适用于构建各种网络...
【开源下载】基于TCP网络通信的即时聊天系统（IM系统）（c#源码）
01-31
c#开源ＩＭ系统 把系统中集成的ＩＭ部分，提取出来，共大家参考，也可以作为大家学习networkcomms框架的一个demo
C# 简单的tcp服务器demo
07-25
C# 简单的tcp服务器demo
C# Socket通讯/TCP通讯，完整代码demo
01-20
C# Socket通讯/TCP通讯，完整代码demo
c#tcp-demo源码
08-27
自己封装的tcp-demo，服务端和客户端一体，仅供参考学习
C# Net.TCP 上连接DEMO
10-19
net.tcp 长连接上下行实例代码。 全部通过代码方式实现net.tcp接口。
C# TcpListener/TcpClient Demo
05-17
C# TcpListener/TcpClient Demo
C# TCP/IP网络聊天工具Demo应用程序
资源摘要信息:"Demo_Apps.zip_DEMO_c# TCP工具是一个演示性质的压缩包文件，其中包含了利用TCP/IP协议实现的网络聊天工具的示例代码，该项目以C#语言编写，旨在演示如何通过网络编程创建一个类似即时消息服务的应用...
C#实现消息发布订阅即时通信Mqtt
08-14
在IT行业中，即时通信（Instant Messaging）是一种常见且重要的技术，尤其在分布式系统和物联网（IoT）领域。本文将详细讲解如何使用C#语言实现基于Mqtt协议的消息发布订阅功能，帮助开发者快速理解和应用这一技术。...
C#上位机：TCP通讯实例
weixin_43736127的博客
10-01 2771
TCP在C#上位机的应用示例
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

望天hous

你的鼓励是我最大动力~谢谢啦！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值