使用socket实现简单的客户端和服务端通信(C#语言)

最新推荐文章于 2024-09-04 07:00:00 发布
最新推荐文章于 2024-09-04 07:00:00 发布
阅读量4.2k 收藏 7
点赞数 1
分类专栏： c# 文章标签： c# socket 消息 服务端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangjijun0807/article/details/45796577
版权

1.主要思路：
(1) 服务端开启监听线程，等待客户端的连接。 每个socket连接放到独立线程中处理。
(2) 服务端和客户端使用约定的消息格式通信。对于比较复杂的消息(如向服务端传递一个实例)，可以使用json封装传输。
(3) 每个连接的客户端，注册唯一的ClientID，在服务端以此来区分消息的来源。
2.代码构成
实现该样例包含两个cs的客户端程序。 分别为 服务端 和 客户端。
3.主要代码：
(1) 服务端 xaml

<Window x:Class="WpfApplication1.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Window1" Height="432" Width="817">
    <Grid>
        <TextBox Height="23" HorizontalAlignment="Left" Margin="16,20,0,0" Name="tbox_listner_ip" Text="127.0.0.1" VerticalAlignment="Top" Width="114" />
        <TextBox Height="23" HorizontalAlignment="Left" Margin="136,20,0,0" Name="tbox_listner_port" Text="2000" VerticalAlignment="Top" Width="43" />
        <Button Content="开启监听" Height="23" HorizontalAlignment="Right" Margin="0,22,440,0" Name="button2" VerticalAlignment="Top" Width="75" Click="button2_Click" />
        <RichTextBox Height="132" HorizontalAlignment="Left" Margin="470,20,0,0" Name="richTextBox1" VerticalAlignment="Top" Width="313" />
        <Grid  Margin="19,82,354,287">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="260" />
                <ColumnDefinition Width="80" />
                <ColumnDefinition  Width="60*" />
            </Grid.ColumnDefinitions>
            <Label Grid.Column="0" Content="来自于" FontWeight="Bold" Padding="0" Height="18"></Label>

            <Label Grid.Column="1" Content="消息号" FontWeight="Bold" Padding="0" Height="18"></Label>
            <Label Grid.Column="2" Content="是否处理" FontWeight="Bold" Padding="0" Height="18"></Label>

        </Grid>
        <ListBox Height="278" HorizontalAlignment="Left" Margin="19,103,0,0" Name="listBox2" VerticalAlignment="Top" Width="422">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Grid>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="260" />
                            <ColumnDefinition Width="80" />
                            <ColumnDefinition Width="60*" />
                        </Grid.ColumnDefinitions>
                        <Label Grid.Column="0" Padding="0" Height="25" Content="{Binding  Path=clientID}"></Label>
                        <Label Grid.Column="1" Padding="0" Height="25" Content="{Binding  Path=messageContent}"></Label>
                        <RadioButton Grid.Column="2" Margin="0,5,0,0" Height="25" IsChecked="{Binding  Path=handleFlag}"></RadioButton>
                    </Grid>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        <RichTextBox Height="132" HorizontalAlignment="Left" Margin="470,193,0,0" Name="richTextBox2" VerticalAlignment="Top" Width="313" />
    </Grid>
</Window>

(2) 服务端 cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Net.Sockets;
using System.Threading;
using System.Net;
using Newtonsoft.Json;

namespace WpfApplication1
{
    /// <summary>
    /// Window1.xaml 的交互逻辑
    /// </summary>
    public partial class Window1 : Window
    {  
        int BufferSize = 1024;
        private bool executeFlag = false; 
        List<MySocketMessage> list_message = new List<MySocketMessage>();
        private int ClientFlag = 1;

        private Socket socket_server;
        public Window1()
        {
            InitializeComponent();
        }



        private void button2_Click(object sender, RoutedEventArgs e)
        {
            button2.IsEnabled = false;
            int listner_port = Convert.ToInt32(tbox_listner_port.Text);
            string listner_ip = tbox_listner_ip.Text; 
            executeFlag = true;

            IPAddress ip_server = IPAddress.Parse(listner_ip);
            IPEndPoint ipEndPoint = new IPEndPoint(ip_server, listner_port);
            socket_server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            socket_server.Bind(ipEndPoint);
            socket_server.Listen(10); //开始监听 (有监听就接收)  设置最多十个排队连接请求


            Thread thread_serve = new Thread(new ThreadStart(CreateListner));
            thread_serve.Name = "server thread";
            thread_serve.Start();  
        }
        private void CreateListner()
        {
            while (true)
            {
                Socket socketConn = socket_server.Accept(); //为建立的连接创建socket  
                EndPoint point = socketConn.RemoteEndPoint;
                AppendStrToRtbox("\n连接来自:" + point.ToString());

                Thread receiveThread = new Thread(ServerHandleMessage);  
                receiveThread.Start(socketConn);  
            }  
        }  

        /// <summary>  
        /// 接收消息  
        /// </summary>  
        /// <param name="clientSocket"></param>  
        private   void ServerHandleMessage(object clientSocket)
        {
            Socket socketConn = clientSocket as Socket;
            string clientID = "";
            while (true)
            {
                if (socketConn.Connected == true)
                {
                    try
                    {
                        string recvStr = GetReceiveStr(socketConn);
                        if (recvStr != "")
                        {
                            if (recvStr.Contains("connectRequest"))
                            {
                                int i_pos = recvStr.IndexOf("connectRequest") + "connectRequest".Length;
                                AppendStrToRtbox("分割字符串前：" + recvStr);
                                recvStr = recvStr.Substring(i_pos, recvStr.Length - i_pos);

                                Send_Mess(socketConn, "Confirm");
                                AppendStrToRtbox(" 连接已被确认，客户ID：" + recvStr);
                                clientID = recvStr;
                                continue;
                            }
                            else if (recvStr.Contains("jsonMessage:"))
                            {
                                int i_pos = recvStr.IndexOf("jsonMessage:") + "jsonMessage:".Length;
                                AppendStrToRtbox("分割字符串前：" + recvStr);
                                recvStr = recvStr.Substring(i_pos, recvStr.Length - i_pos);
                                AppendStrToRtbox("分割字符串后：" + recvStr);

                                MySocketMessage socketMessage = JsonConvert.DeserializeObject<MySocketMessage>(recvStr); 
                                list_message.Add(socketMessage); 
                            }

                            MySocketMessage message_tmp = list_message.Find(p => p.clientID == clientID && p.isDoing == true);
                            if (message_tmp != null)
                            {
                                message_tmp.isDoing = false; 
                                message_tmp.dt_message_handleTime = DateTime.Now;

                                RefreshListBox();

                                string sendStr = "ReturnCode:" + message_tmp.messageContent;
                                Send_Mess(socketConn, sendStr);

                                AppendStrToRtbox_two(String.Format("消息来自{0},指令:{1}", clientID, message_tmp.messageContent));
                                AppendStrToRtbox(" 执行请求指令：" + recvStr);
                                continue;
                            }

                            string sendStr2 = "Confirm";
                            Send_Mess(socketConn, sendStr2);
                        }
                    }
                    catch (Exception ce)
                    {
                        executeFlag = false;
                        AppendStrToRtbox("服务端检测到客户端连接断开");
                    }
                }
                else
                {
                    executeFlag = false;
                    AppendStrToRtbox("服务端检测到客户端连接断开");
                }

                Thread.Sleep(50);
            }
        } 

        public string GetReceiveStr(Socket socket_tmp)
        {
            //接受从服务器返回的信息  
            byte[] recvBytes = new byte[BufferSize];

            int bytes;
            string recvStr = "";
            bytes = socket_tmp.Receive(recvBytes, recvBytes.Length, 0); //从服务器端接受返回
            if (bytes > 0)
            {
                recvStr += Encoding.ASCII.GetString(recvBytes, 0, bytes);
                Console.WriteLine("\nGetReceiveStr 客户端接收到服务端的返回：" + recvStr);
            }
            return recvStr;
        }
        /// <summary>
        /// 发送消息指令
        /// </summary>
        /// <param name="sendMessage"></param>
        public void Send_Mess(Socket socket_tmp,string sendMessage)
        {
            if (socket_tmp.Connected == false)
            {
                return;
            }
            byte[] send_bytes = Encoding.ASCII.GetBytes(sendMessage); //把字符串编码为字节  
            if (send_bytes.Length > 0)
            {
                socket_tmp.Send(send_bytes, send_bytes.Length, 0);
            }
        }
        private void AppendStrToRtbox(string content)
        {
            this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal,
                   new Action(() =>
                   {
                       richTextBox1.AppendText("\n" + content);
                       richTextBox1.ScrollToEnd();
                   }
             ));
        }
        private void AppendStrToRtbox_two(string content)
        {
            this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal,
                   new Action(() =>
                   {
                       richTextBox2.AppendText("\n" + content);
                       richTextBox2.ScrollToEnd();
                   }
             ));
        }
        private void RefreshListBox()
        {
            this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal,
                   new Action(() =>
                   {

                       listBox2.ItemsSource = new List<MySocketMessage>();
                       listBox2.ItemsSource = list_message; 
                   }
             ));
        } 
    }

    public class MySocketMessage
    {
        public MySocketMessage()
        {
            handleFlag = false;
            isDoing = false;
        }
        public string clientID { get; set; }
        public string messageContent { get; set; }
        public DateTime dt_message_addTime { get; set; }
        public DateTime dt_message_handleTime { get; set; }
        public bool handleFlag { get; set; }
        public bool isDoing { get; set; }
    }
}

(3) 客户端 xaml

 <Window x:Class="WpfApplication1.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Window1" Height="432" Width="734">
    <Grid>
        <TextBox Height="23" HorizontalAlignment="Left" Margin="18,40,0,0" Name="tbox_client_ip" Text="127.0.0.1" VerticalAlignment="Top" Width="114" />
        <TextBox Height="23" HorizontalAlignment="Left" Margin="138,40,0,0" Name="tbox_client_port" Text="2000" VerticalAlignment="Top" Width="43" />
        <Button Content="建立连接，并发送消息" Height="23" HorizontalAlignment="Left" Margin="199,42,0,0" Name="button3" VerticalAlignment="Top" Width="147" Click="button3_Click" />
        <RichTextBox Height="132" HorizontalAlignment="Left" Margin="373,21,0,0" Name="richTextBox1" VerticalAlignment="Top" Width="313" />
        <Button Content="发送指令" Height="23" HorizontalAlignment="Left" Margin="199,123,0,0" Name="button4" VerticalAlignment="Top" Width="95" Click="button4_Click" />
        <ListBox Height="69" HorizontalAlignment="Left" Margin="18,123,0,0" Name="listBox1" VerticalAlignment="Top" Width="163">
            <ListBoxItem Content="1001" />
            <ListBoxItem Content="1002" />
            <ListBoxItem Content="1003" />
            <ListBoxItem Content="1004" />
            <ListBoxItem Content="1005" />
        </ListBox>
        <Label Content="指令序列" Height="28" HorizontalAlignment="Left" Margin="21,89,0,0" Name="label1" VerticalAlignment="Top" />
        <Grid  Margin="21,223,531,142">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="100" />
                <ColumnDefinition  Width="60" />
            </Grid.ColumnDefinitions>
            <Label Grid.Column="0" Content="消息内容" FontWeight="Bold" Padding="0" Height="18"></Label>

            <Label Grid.Column="1" Content="是否处理" FontWeight="Bold" Padding="0" Height="18"></Label>
        </Grid>
        <ListBox Height="103" HorizontalAlignment="Left" Margin="18,249,0,0" Name="listBox2" VerticalAlignment="Top" Width="163">
            <ListBox.ItemTemplate>
                <DataTemplate>
                    <Grid>
                        <Grid.ColumnDefinitions>
                            <ColumnDefinition Width="60" />
                            <ColumnDefinition  Width="60" />
                        </Grid.ColumnDefinitions>
                        <Label Grid.Column="0" Padding="0" Height="25" Content="{Binding  Path=messageContent}"></Label>
                        <RadioButton  Grid.Column="1"  Margin="0,5,0,0" Height="25" IsChecked="{Binding  Path=handleFlag}"></RadioButton> 
                    </Grid>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
        <RichTextBox Height="132" HorizontalAlignment="Left" Margin="373,200,0,0" Name="richTextBox2" VerticalAlignment="Top" Width="313" />
    </Grid>
</Window>

(4) 客户端 cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Net.Sockets;
using System.Threading;
using System.Net;
using Newtonsoft.Json;

namespace WpfApplication1
{
    /// <summary>
    /// Window1.xaml 的交互逻辑
    /// </summary>
    public partial class Window1 : Window
    { 

        int BufferSize = 1024;
        private bool executeFlag = false; 
        List<MySocketMessage> list_message = new List<MySocketMessage>();
        private int ClientFlag = 1;
        private string clientGUID = "";
        Socket socket_client;
        public Window1()
        {
            InitializeComponent();
        }

        private void button3_Click(object sender, RoutedEventArgs e)
        {
            int port = Convert.ToInt32(tbox_client_port.Text);
            string host = tbox_client_ip.Text;
            CreateConnect(host, port);
        }


        private void CreateConnect(string host, int port)
        {
            //创建终结点EndPoint

            IPAddress ip = IPAddress.Parse(host);
            IPEndPoint ipe = new IPEndPoint(ip, port); //把ip和端口转化为IPEndPoint的实例 
            //创建Socket并连接到服务器

            socket_client  = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            // 创建Socket

            Console.WriteLine("Connecting...");
            socket_client.Connect(ipe); //连接到服务器 


            //向服务器发送信息 
            Thread thread_client = new Thread(ClientMethod);
            thread_client.Name = "client thread" + ClientFlag.ToString();

            thread_client.Start(socket_client);


            ClientFlag++;
        }


        private void ClientMethod(object socket)
        {
            Socket socket_client = socket as Socket;
            clientGUID = Guid.NewGuid().ToString();
            string sendStr_connect = "connectRequest" + clientGUID; 
            Send_Mess(socket_client, sendStr_connect); 

            try
            {
                byte[] recvBytes = new byte[1024];
                while (true)
                { 

                    List<MySocketMessage> list_not_handle = list_message.FindAll(p => p.handleFlag == false);
                    if (list_not_handle != null && list_not_handle.Count > 0)
                    {
                        //每次只处理第一条
                        string sendStr = list_not_handle.First().messageContent;
                        list_not_handle.First().isDoing = true; 
                        list_not_handle.First().handleFlag = true;


                        string jsonStr = "jsonMessage:" + JsonConvert.SerializeObject(list_not_handle.First());
                        Send_Mess(socket_client, jsonStr); 
                        string receiveStr = GetReceiveStr(socket_client);  //收到的内容
                        if (receiveStr.Contains("ReturnCode:"))
                        {
                            if (receiveStr.Contains(list_not_handle.First().messageContent))
                            {
                                int i_pos = receiveStr.IndexOf("ReturnCode:") + 11;
                                AppendStrToRtbox("分割字符串前：" + receiveStr);
                                receiveStr = receiveStr.Substring(i_pos, receiveStr.Length - i_pos);
                                AppendStrToRtbox("发送指令后，服务端返回：" + receiveStr + "线程号：" + Thread.CurrentThread.Name);

                                RefreshListBox();
                            } 
                        } 
                    }
                    else
                    {
                        string receiveStr = GetReceiveStr(socket_client);  //收到的内容
                        if (receiveStr.Equals("Confirm"))
                        {
                            AppendStrToRtbox_two("发送指令后，服务端返回：" + receiveStr);
                        } 

                        Send_Mess(socket_client, "online");
                    }

                    Thread.Sleep(50);

                }
            }
            catch (Exception ce)
            {
                executeFlag = false;
                AppendStrToRtbox("客户端检测到服务端连接断开");
            }
        }
        public string GetReceiveStr(Socket socket_tmp)
        {
            //接受从服务器返回的信息  
            byte[] recvBytes = new byte[BufferSize];

            int bytes;
            string recvStr = "";
            bytes = socket_tmp.Receive(recvBytes, recvBytes.Length, 0); //从服务器端接受返回
            if (bytes > 0)
            {
                recvStr += Encoding.ASCII.GetString(recvBytes, 0, bytes);
                Console.WriteLine("\nGetReceiveStr 客户端接收到服务端的返回：" + recvStr);
            }
            return recvStr;
        }
        /// <summary>
        /// 发送消息指令
        /// </summary>
        /// <param name="sendMessage"></param>
        public void Send_Mess(Socket socket_tmp,string sendMessage)
        {
            if (socket_tmp.Connected == false)
            {
                return;
            }
            byte[] send_bytes = Encoding.ASCII.GetBytes(sendMessage); //把字符串编码为字节  
            if (send_bytes.Length > 0)
            {
                socket_tmp.Send(send_bytes, send_bytes.Length, 0);
            }
        }
        private void AppendStrToRtbox(string content)
        {

            this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal,
                   new Action(() =>
                   {
                       this.Title = "客户端号：" + clientGUID;
                       if (richTextBox1.Document.Blocks.Count > 100)
                       {
                           richTextBox1.Document.Blocks.Clear();
                       }
                       richTextBox1.AppendText("\n" + content);
                       richTextBox1.ScrollToEnd();
                   }
             ));
        }
        private void AppendStrToRtbox_two(string content)
        {
            this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal,
                   new Action(() =>
                   {
                       this.Title = "客户端号：" + clientGUID;
                       if (richTextBox2.Document.Blocks.Count > 100)
                       {
                           richTextBox2.Document.Blocks.Clear();
                       }
                       richTextBox2.AppendText("\n" + content);
                       richTextBox2.ScrollToEnd();
                   }
             ));
        }
        private void RefreshListBox()
        {
            this.Dispatcher.BeginInvoke(System.Windows.Threading.DispatcherPriority.Normal,
                   new Action(() =>
                   {

                       listBox2.ItemsSource = new List<MySocketMessage>();
                       listBox2.ItemsSource = list_message; 
                   }
             ));
        }

        private void button4_Click(object sender, RoutedEventArgs e)
        {
            ListBoxItem  lbi = listBox1.SelectedItem as ListBoxItem;
            if (lbi == null)
            {
                return;
            }
            string message = lbi.Content.ToString();
            MySocketMessage message_tmp = new MySocketMessage();
            message_tmp.messageContent = message;
            message_tmp.dt_message_addTime = DateTime.Now;
            message_tmp.clientID = clientGUID;



            list_message.Add(message_tmp);

            listBox2.ItemsSource = new List<MySocketMessage>();
            listBox2.ItemsSource = list_message; 
        }


    }

    public class MySocketMessage
    {
        public MySocketMessage()
        {
            handleFlag = false;
            isDoing = false;
        }
        public string clientID { get; set; }
        public string messageContent { get; set; }
        public DateTime dt_message_addTime { get; set; }
        public DateTime dt_message_handleTime { get; set; }
        public bool handleFlag { get; set; }
        public bool isDoing { get; set; }
    }
}

4.未考虑的问题
(1) 消息的优先级
(2) 消息传递中的异常处理

ps: 最近工作中看到厂家的socket的接口，他们提供了非常标准的指令文档。在该厂家接口的定义中，对服务端的所有请求一定有返回消息。因此，我的样例代码中，服务端和客户端之间一直有消息传递。
以上代码的价值仅仅在于描述了服务端和客户端保持通信的一种简单实现，不少代码来自互联网。

我是王老吉吖
关注
专栏目录
C语言实现socket服务端和客户端
05-28
使用C语言实现的socket的服务端和客户端
java socket 服务器 客户端_Java使用socket搭建简易服务器和客户端
weixin_34644635的博客
02-12 442
其实使用socket搭建一个简易的服务器只需要一行代码，那就是ServerSocket server = new ServerSocket(intport);port 的值是一个端口号，一般大于5000即可。然后当等有用户连接时，服务器开始创建socket。Socket client = server.accept();这时可以创建输入流InputStream in = client.getInp...
C# 中的 Socket 编程
最新发布
java专栏
09-04 656
大家好！我是你们的编程小伙伴，今天咱们要一起学习 C# 中的 Socket 编程。Socket 编程可能听起来有点儿高大上，但其实它就像是一对朋友之间的对话，只不过这些朋友是电脑而已。通过 Socket，电脑们可以相互发送消息，就像你我之间发短信一样简单。那么，咱们就从最基本的开始讲起吧！Socket是一种用于进程间通信的机制，它让不同计算机上的程序能够相互通信。在 C# 中，我们主要使用命名空间中的Socket类来实现 Socket 编程。
socket客户端服务器c语言,纯C语言版本的socket.io服务器端实现
weixin_30794381的博客
05-19 481
前言哈，这又是一个socket.io服务端实现，本意是，拿C练练手，加强对C和linux系统的理解，写着写着，就写成了一个socket.io服务器端实现了。以为半成品，那就正式托管在github站点上吧，以便记录一下，可让大家批评与指正，加强内功的修炼等。以下部分文字，偷懒，摘录自项目的README.md文件说明这是一个纯C语言版本的socket.io服务器端实现，目前仅支持linux系统，严重依...
c语言实现socket编程--客户端与客户端之间通过服务器进行通讯
热门推荐
xiximimio的博客
08-22 1万+
#include <stdio.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <string.h> #include <unistd.h> #include <stdlib.h> #include...
Socket编程实现简单的服务器与客户端互发消息
wangxiaohong123的专栏
07-08 6062
socket编程的大致步骤如下:1、创建服务器端SocketServer,并定义SocketServer的监听端口;2、ServerSocket调用accept( )方法，是指处于阻塞；3、创建客户端的Socket，并设置服务器的IP和端口；4、客户端发送连接请求，建立连接；5、
C#使用Socket实现服务器与多个客户端通信(简单的聊天系统)
08-25
C#使用Socket实现服务器与多个客户端通信（简单的聊天系统）是指使用C#语言通过Socket编程来实现服务器与多个客户端之间的通信，实现一个简单的聊天系统。该系统的核心是服务器端使用Socket监听客户端的连接请求，...
C#Socket编程 实现客户端与服务端通信
08-01
总之，C#的Socket编程提供了构建网络通信应用的基础，通过创建Socket对象、绑定端口、连接服务器、发送和接收数据，开发者可以实现客户端与服务端之间的高效通信。在学习过程中，理解Socket的工作原理和正确使用C#的...
C#利用Socket实现客户端之间直接通信
09-29
C#利用Socket实现客户端之间直接通信 实验功能：  设计程序，分别构建通信的两端:服务器端和客户端应用程序,套接字类型为面向连接的Socket,自己构建双方的应答模式，实现双方的数据的发送和接收（S发给C，C发给S）...
C#SuperSocket服务端与客户端通信实例
09-17
本教程将深入探讨如何使用C#编程语言以及SuperSocket库来构建一个高效、稳定的服务器端和客户端通信模型。SuperSocket是一个轻量级且易于使用的.NET Socket服务端开发框架，它为开发者提供了构建自定义网络应用的...
C#语言编写的Socket通信客户端和服务端
10-20
总之，C#提供的Socket类为开发者提供了实现客户端和服务端网络通信的强大工具。通过理解和应用这些概念，你可以构建出可靠、高效且可扩展的网络应用程序。在实际项目中，FrmServer和FrmClient文件将具体实现上述逻辑...
C#高性能大容量SOCKET并发完成端口例子（有C#客户端）完整实例源码
12-10
例子主要包括SocketAsyncEventArgs通讯封装、服务端实现日志查看、SCOKET列表、上传、下载、远程文件流、吞吐量协议，用于测试SocketAsyncEventArgs的性能和压力，最大连接数支持65535个长连接，最高命令交互速度达到250MB/S（使用的是127.0.0.1的方式，相当于千兆网卡1Gb=125MB/S两倍的吞吐量）。服务端用C#编写，并使用log4net作为日志模块； 同时支持65536个连接，网络吞吐量可以达到400M。
基于SocketAsyncEventArgs(IOCP)实现的高并发TCP客户端
10-10
我需要大量的设备同时向这个服务器软件发送信息，但是一般情况，在开发中不可能同时提供这么大量的设备，因此需要我们做一个模拟的软件，在网络上搜索了很久，发现都不太符合我个人的需求，那么在翻阅大量大神的文章之后，自己做了一个模拟软件，不太成熟，欢迎各位指正。
基于TCP的socket简易聊天程序(服务端和客户端)
weixin_40789841的博客
01-07 3993
基于TCP的socket程序服务端和客户端，基本要求：客户端能发送消息到服务端，服务端再把此消息返回给客户端。 1.1服务端：         （1）. 初始化WSA，构建一个Socket，指定本地的端口，用于监听其连接请求。      （2）.调用socket的accept()方法获得客户端的连接请求，建立与客户端的连接。      （3）.进行数据的写入和读出。 （4）.调用clos...
Socket编程---简单的聊天工具
zs1342084776的博客
06-19 1251
1）Socket编程： 通过TCP或者UDP协议进行多台主机之间的通讯 编写程序实现两台电脑之间进行通讯，比如实现一个简单的在线聊天工具 2）聊天工具的开发： 一台电脑的客户端作为服务器端，另一台电脑作为客户端 服务器端开启自己电脑的一个端口，监听这其它电脑对这端口的请求 一旦发现有电脑接入，则...
C#高性能大容量SOCKET并发(转)
weixin_33939843的博客
12-20 1213
C#高性能大容量SOCKET并发（零）：代码结构说明  C#高性能大容量SOCKET并发（一）：IOCP完成端口例子介绍 C#高性能大容量SOCKET并发（二）：SocketAsyncEventArgs封装 C#高性能大容量SOCKET并发（三）：接收、发送 C#高性能大容量SOCKET并发（四）：缓存设计 C#高性能大容量SOCKET并发（五）：粘包、分包、解包  C#高性能大容量S...
C#SocketAsyncEventArgs实现高效能多并发TCPSocket通信 (客户端实现)
freshflower
03-21 1689
    上一篇讲了服务器端的实现, 这一篇就是客户端的实现.     服务器实现参考：《C#如何利用SocketAsyncEventArgs实现高效能TCPSocket通信 (服务器实现)》      与服务器不同的是客户端的实现需要多个SocketAsyncEventArgs共同协作，至少需要两个：接收的只需要一个，发送的需要一个，也可以多个,这在多线程中尤为重要，接下来说明。   ...
C#SocketAsyncEventArgs实现高效能多并发TCPSocket通信 (服务器实现)
Elon的博客
01-19 9115
转载出处: http://freshflower.iteye.com/blog/2285272 想着当初到处找不到相关资料来实现.net的Socket通信的痛苦与心酸, 于是将自己写的代码公布给大家, 让大家少走点弯路, 以供参考. 若是觉得文中的思路有哪里不正确的地方, 欢迎大家指正, 共同进步.      说到Socket通信, 必须要有个服务端, 打开一个端口进行监听(废话!
c#登录实现到socket通信
Junit的博客
03-01 892
登录窗体：using MyWPFTest.bean;using MyWPFTest.domain;using System;using System.Data;using System.Data.SqlClient;using System.Windows;using System.Windows.Media;namespace MyWPFTest{    /// &lt;summary&gt; ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值