C#實現伺服器和客戶端之間通訊

阿新 • • 發佈：2018-12-24

TCP 套接字程式設計

伺服器端實現步驟：

1、使用Socket類建立套接字。

2、利用Bind方法將建立的套接字繫結到指定的地址結構。

3、利用Listen方法設定套接字為監聽模式，使得伺服器進入被動開啟狀態。

4、接受客戶端的連線請求。

5、接收、應答客戶端的資料請求。

6、終止連線。

客戶端實現步驟：

1、使用Socket類建立套接字。

2、呼叫Connect方法建立一個與TCP伺服器的連線。

3、傳送資料請求，接受伺服器的資料應答。

4、終止連線。

一對一：

客戶端程式碼：

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
namespace Client
{
    class Problem
    {
        private static byte[] result = new byte[1024 * 1024];
        static Socket ClientSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
        static void Main(string[] args)
        {
            int Port = 8222;
            IPAddress IP = IPAddress.Parse("127.0.0.1");
            try
            {
                Console.WriteLine("連線伺服器成功！！！");
                ClientSocket.Connect(new IPEndPoint(IP,Port));
            }
            catch(Exception ex)
            {
                Console.WriteLine("連線伺服器失敗，按回車鍵退出！");
                return;
            }
            for(int i=0;i<10;i++)
            {
                try
                {
                    Thread.Sleep(2000);
                    int ReceiveLength = ClientSocket.Receive(result);
                    Console.WriteLine("接收伺服器訊息：{0}",Encoding.ASCII.GetString(result,0,ReceiveLength));
                    Console.WriteLine("向伺服器傳送訊息：");
                    string sb = Console.ReadLine();
                    string SendMessage = "向伺服器傳送訊息：" + DateTime.Now + "\n" + sb;
                    ClientSocket.Send(Encoding.ASCII.GetBytes(SendMessage));
                }
                catch(Exception ex)
                {
                    ClientSocket.Shutdown(SocketShutdown.Both);
                    ClientSocket.Close();
                }
            }
            Console.WriteLine("訊息傳送完畢！！！");
            Console.WriteLine();
        }
    }
}

伺服器程式碼：

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
namespace Server
{
    class Program
    {
        public static void ListenClientConnect()
        {
            while(true)
            {
                Socket ClientSocket = ServerSocket.Accept();//send
                Console.WriteLine("向客戶端傳送訊息：");
                string sb = Console.ReadLine();
                ClientSocket.Send(Encoding.ASCII.GetBytes("Server Say Hello:"+sb));
                Thread thread = new Thread(ReceiveMessage);
                thread.Start(ClientSocket);
            }
        }
        public static void ReceiveMessage(Object ClientSocket)
        {
            Socket MyClientSocket = (Socket)ClientSocket;
            while(true)
            {
                try
                {
                    int ReceiveNum = MyClientSocket.Receive(result);
                    Console.WriteLine("接受客戶端{0}訊息{1}：" ,MyClientSocket.RemoteEndPoint.ToString(),
                       Encoding.ASCII.GetString(result,0,ReceiveNum));
                    Console.WriteLine("向客戶端傳送訊息：");
                    string sb = Console.ReadLine();
                    MyClientSocket.Send(Encoding.ASCII.GetBytes(sb));
                }
                catch(Exception ex)
                {
                    Console.WriteLine("404 Not found！！！");
                    MyClientSocket.Shutdown(SocketShutdown.Both);
                    MyClientSocket.Close();
                }
            }
        }
        private static byte[] result = new byte[1024 * 1024];
        static Socket ServerSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
        static void Main(String[] args)
        {
            try
            {
                int Port = 8222;
                IPAddress IP = IPAddress.Parse("127.0.0.1");
                ServerSocket.Bind(new IPEndPoint(IP, Port));
                ServerSocket.Listen(10);
                Console.WriteLine("啟動監聽{0}成功",ServerSocket.LocalEndPoint.ToString());
                Thread thread = new Thread(ListenClientConnect);
                thread.Start();
                Thread.Sleep(2000);
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }
    }
}

一對多：

服務端程式碼：

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
using System.Linq;
namespace Server
{
    class Program
    {
        public static void ListenConnection()
        {
            Socket ConnectionSocket = null;
            while(true)
            {
                try
                {
                    ConnectionSocket = ServerSocket.Accept();
                }
                catch(Exception ex)
                {
                    Console.WriteLine("監聽套接字異常{0}",ex.Message);
                    break;
                }
                //獲取客戶端埠號和IP
                IPAddress ClientIP=(ConnectionSocket.RemoteEndPoint as IPEndPoint).Address;
                int ClientPort = (ConnectionSocket.RemoteEndPoint as IPEndPoint).Port;
                string SendMessage = "連線伺服器成功\r\n" + "本地IP:" + ClientIP +
                    ",本地埠:" + ClientPort.ToString();
                //Console.WriteLine(SendMessage);
                ConnectionSocket.Send(Encoding.UTF8.GetBytes(SendMessage));
                string remotePoint = ConnectionSocket.RemoteEndPoint.ToString();
                Console.WriteLine("成功與客戶端{0}建立連線!\t\n", remotePoint);
                ClientInformation.Add(remotePoint, ConnectionSocket);
                Thread thread = new Thread(ReceiveMessage);
                thread.IsBackground = true;
                thread.Start(ConnectionSocket);
            }
        }
        public static void ReceiveMessage(Object SocketClient)
        {
            Socket ReceiveSocket = (Socket)SocketClient;
            while(true)
            {
                byte[] result = new byte[1024 * 1024];
                try
                {
                    IPAddress ClientIP = (ReceiveSocket.RemoteEndPoint as IPEndPoint).Address;
                    int ClientPort = (ReceiveSocket.RemoteEndPoint as IPEndPoint).Port;
                    int ReceiveLength = ReceiveSocket.Receive(result);
                    string ReceiveMessage = Encoding.UTF8.GetString(result, 0, ReceiveLength);
                    Console.WriteLine("接收客戶端:" + ReceiveSocket.RemoteEndPoint.ToString()+
                        "時間："+DateTime.Now.ToString()+"\r\n"+"訊息："+ReceiveMessage+"\r\n\n");
                    foreach(string key in new List<string>(ClientInformation.Keys))
                    {
                        string s = ReceiveSocket.RemoteEndPoint.ToString();
                        if(key!=s)
                        {
                            Socket socket = ClientInformation[key];
                            Console.WriteLine("向客戶端{0}傳送訊息：", key);
                            socket.Send(Encoding.UTF8.GetBytes(ReceiveMessage));
                        }
                    }
                    //Console.WriteLine("向客戶端{0}傳送訊息：", ReceiveSocket.RemoteEndPoint.ToString());
                    //string sb = Console.ReadLine();
                    //ReceiveSocket.Send(Encoding.UTF8.GetBytes(sb));
                }
                catch(Exception ex)
                {
                    Console.WriteLine("監聽出現異常!!!");
                    Console.WriteLine("客戶端" + ReceiveSocket.RemoteEndPoint + "已經連線中斷" + "\r\n" +
                        ex.Message + "\r\n" + ex.StackTrace + "\r\n");
                    foreach(string key in new List<string>(ClientInformation.Keys))
                    {
                        string s = ReceiveSocket.RemoteEndPoint.ToString();
                        if (key.Equals(s))
                        {
                            ClientInformation.Remove(key);
                        }
                    }
                    ReceiveSocket.Shutdown(SocketShutdown.Both);
                    ReceiveSocket.Close();
                    break;
                }
            }
        }
        //private static byte[] result = new byte[1024];
        //List<Socket> list = new List<Socket>();
        static Dictionary<string, Socket> ClientInformation = new Dictionary<string, Socket> { };
        static Socket ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        static void Main(String[] args)
        {
            try
            {
                int Port = 8333;
                IPAddress IP = IPAddress.Parse("127.0.0.1");
                ServerSocket.Bind(new IPEndPoint(IP, Port));
                ServerSocket.Listen(10);
                Console.WriteLine("啟動監聽成功！");
                Console.WriteLine("監聽本地{0}成功", ServerSocket.LocalEndPoint.ToString());
                Thread ThreadListen = new Thread(ListenConnection);
                ThreadListen.IsBackground = true;
                ThreadListen.Start();
                Thread.Sleep(2000);
            }
            catch(Exception ex)
            {
                Console.WriteLine("監聽異常!!!");
                ServerSocket.Shutdown(SocketShutdown.Both);
                ServerSocket.Close();
            }
            Console.ReadKey();
            Console.WriteLine("監聽完畢，按任意鍵退出！");
        }
    }
}

客戶端程式碼：

using System;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Text;
namespace Client
{
    class Problem
    {
        private static byte[] result = new byte[1024 * 1024];
        static Socket ClientSocket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
        public static void ReceiveMessage()
        {
            while(true)
            {
                try
                {
                    int ReceiveLength = ClientSocket.Receive(result);
                    Console.WriteLine("接收伺服器訊息：{0}", Encoding.UTF8.GetString(result, 0, ReceiveLength));
                }
                catch(Exception ex)
                {
                    Console.WriteLine("出現異常了！！！");
                    Console.WriteLine(ex.Message);
                    ClientSocket.Shutdown(SocketShutdown.Both);
                    ClientSocket.Close();
                    break;
                }
            }
        }
        static void Main(string[] args)
        {
            int Port = 8333;
            IPAddress IP = IPAddress.Parse("127.0.0.1");
            try
            {
                ClientSocket.Connect(new IPEndPoint(IP,Port));
                Thread thread = new Thread(ReceiveMessage);
                thread.Start();
                Thread.Sleep(2000);
            }
            catch(Exception ex)
            {
                Console.WriteLine("連線伺服器失敗，按回車鍵退出！");
                return;
            }
            Console.WriteLine("連線伺服器成功！！！");
            //int ReceiveLength = ClientSocket.Receive(result);
            //Console.WriteLine("接收伺服器訊息：{0}", Encoding.UTF8.GetString(result, 0, ReceiveLength));
            while (true)
            {
                try
                {
                    Thread.Sleep(2000);
                    Console.WriteLine("向伺服器傳送訊息：");
                    string sb = Console.ReadLine();
                    string Client = ClientSocket.RemoteEndPoint.ToString();
                    string SendMessage = "接收客戶端" + Client + "訊息：" + DateTime.Now + "\n" + sb;
                    ClientSocket.Send(Encoding.ASCII.GetBytes(sb));
                }
                catch(Exception ex)
                {
                    ClientSocket.Shutdown(SocketShutdown.Both);
                    ClientSocket.Close();
                    break;
                }
            }
            Console.WriteLine("訊息傳送完畢！！！");
            Console.ReadLine();
        }
    }
}

下面是一對多的使用窗體介面顯示的程式碼以及顯示效果：

客戶端程式碼：

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.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.IO;
namespace ClientForm
{
    public partial class Form1 : Form
    {
        private byte[] result = new byte[1024 * 1024];
        private Socket ClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        public Form1()
        {
            InitializeComponent();
            TextBox.CheckForIllegalCrossThreadCalls = false;
        }
        private void Form1_Load(object sender, EventArgs e)
        {
            ;
        }
        private void textBox1_TextChanged(object sender, EventArgs e)//輸入訊息
        {
            //;
            string str = Console.ReadLine();
            textBox1.Text += str;
        }
        private void textBox2_TextChanged(object sender, EventArgs e)//ip
        {
            ;
        }
        private void textBox3_TextChanged(object sender, EventArgs e)//port
        {
            ;
        }
        private void button1_Click(object sender, EventArgs e)//傳送訊息
        {
            try
            {
                //Thread.Sleep(2000);
                richTextBox1.Text += "向伺服器傳送訊息:\r\n";
                richTextBox1.Text += textBox1.Text + "\r\n";
                string sb = textBox1.Text;
                string Client = ClientSocket.RemoteEndPoint.ToString();
                string SendMessage = "接收客戶端" + Client + "訊息：" + DateTime.Now + "\r\n" + sb + "\r\n";
                ClientSocket.Send(Encoding.UTF8.GetBytes(sb));
                textBox1.Clear();
            }
            catch (Exception ex)
            {
                richTextBox1.Text += "伺服器可能已經關閉！\r\n";
                ClientSocket.Shutdown(SocketShutdown.Both);
                ClientSocket.Close();
            }
        }
        private void button2_Click(object sender, EventArgs e)//連線伺服器
        {
            int Port = Convert.ToInt32(textBox3.Text);
            IPAddress IP = IPAddress.Parse((string)textBox2.Text);
            try
            {
                ClientSocket.Connect(new IPEndPoint(IP, Port));
                richTextBox2.Text += "連線伺服器成功！\r\n";
                Thread thread = new Thread(ReceiveMessage);
                thread.IsBackground = true;
                thread.Start();
            }
            catch (Exception ex)
            {
                richTextBox2.Text += "連線伺服器失敗！\r\n";
                return;
            }
        }
        private void label1_Click(object sender, EventArgs e)
        {
            ;
        }
        private void label2_Click(object sender, EventArgs e)
        {
            ;
        }
        private void richTextBox1_TextChanged(object sender, EventArgs e)//顯示傳送的訊息
        {
            ;
        }
        private void richTextBox2_TextChanged(object sender, EventArgs e)//顯示接收的訊息
        {
            ;
        }
        private void ReceiveMessage()
        {
            while (true)
            {
                try
                {
                    int ReceiveLength = ClientSocket.Receive(result);
                    richTextBox2.Text += "接收伺服器訊息：\r\n";
                    string str = Encoding.UTF8.GetString(result, 0, ReceiveLength)+"\r\n";
                    richTextBox2.Text += str;
                }
                catch (Exception ex)
                {
                    richTextBox2.Text += "接收訊息失敗！\r\n";
                    ClientSocket.Shutdown(SocketShutdown.Both);
                    ClientSocket.Close();
                    break;
                }
            }
        }
    }
}

服務端程式碼：

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.Windows.Forms;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.IO;
using System.Threading;
namespace ServerForm
{
    public partial class Form1 : Form
    {
        private byte[] result = new byte[1024 * 1024];
        private Socket ServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        private Dictionary<string, Socket> ClientInformation = new Dictionary<string, Socket> { };
        public Form1()
        {
            InitializeComponent();
            TextBox.CheckForIllegalCrossThreadCalls = false;
            //在多執行緒程式中，新建立的執行緒不能訪問UI執行緒建立的視窗控制元件
            //如果需要訪問視窗控制元件則可以如此設定
        }
        private void label1_Click(object sender, EventArgs e)//ip
        {

        }
        private void label2_Click(object sender, EventArgs e)//Port
        {

        }
        private void label3_Click(object sender, EventArgs e)//線上列表
        {

        }
        private void richTextBox1_TextChanged(object sender, EventArgs e)//顯示客戶端之間/客戶端訊息
        {

        }
        private void richTextBox2_TextChanged(object sender, EventArgs e)//顯示連線成功或者掉線的客戶端
        {

        }
        private void richTextBox3_TextChanged(object sender, EventArgs e)//顯示線上列表
        {

        }
        private void textBox1_TextChanged(object sender, EventArgs e)//IP
        {

        }
        
        private void textBox2_TextChanged(object sender, EventArgs e)//Port
        {

        }
        private void button1_Click(object sender, EventArgs e)//啟動服務
        {
            try
            {
                int Port = Convert.ToInt32(textBox2.Text);
                IPAddress IP = IPAddress.Parse((string)textBox1.Text);
                ServerSocket.Bind(new IPEndPoint(IP, Port));
                ServerSocket.Listen(10);
                richTextBox2.Text += "啟動監聽成功！\r\n";
                richTextBox2.Text += "監聽本地" + ServerSocket.LocalEndPoint.ToString() + "成功\r\n";
                Thread ThreadListen = new Thread(ListenConnection);
                ThreadListen.IsBackground = true;
                ThreadListen.Start();
                Thread.Sleep(2000);
            }
            catch(Exception ex)
            {
                richTextBox2.Text += "監聽異常！！！\r\n";
                ServerSocket.Shutdown(SocketShutdown.Both);
                ServerSocket.Close();
            }
        }
        private void ListenConnection()
        {
            Socket ConnectionSocket = null;
            while (true)
            {
                try
                {
                    ConnectionSocket = ServerSocket.Accept();
                }
                catch (Exception ex)
                {
                    richTextBox2.Text += "監聽套接字異常" + ex.Message;
                    //Console.WriteLine("監聽套接字異常{0}", ex.Message);
                    break;
                }
                //獲取客戶端埠號和IP
                IPAddress ClientIP = (ConnectionSocket.RemoteEndPoint as IPEndPoint).Address;
                int ClientPort = (ConnectionSocket.RemoteEndPoint as IPEndPoint).Port;
                string SendMessage = "本地IP:" + ClientIP +
                    ",本地埠:" + ClientPort.ToString();
                ConnectionSocket.Send(Encoding.UTF8.GetBytes(SendMessage));
                string remotePoint = ConnectionSocket.RemoteEndPoint.ToString();
                richTextBox2.Text += "成功與客戶端" + remotePoint + "建立連線\r\n";
                richTextBox3.Text += DateTime.Now+":"+remotePoint + "\r\n";
                ClientInformation.Add(remotePoint, ConnectionSocket);
                Thread thread = new Thread(ReceiveMessage);
                thread.IsBackground = true;
                thread.Start(ConnectionSocket);
            }
        }
        private void ReceiveMessage(Object SocketClient)
        {
            Socket ReceiveSocket = (Socket)SocketClient;
            while (true)
            {
                byte[] result = new byte[1024 * 1024];
                try
                {
                    IPAddress ClientIP = (ReceiveSocket.RemoteEndPoint as IPEndPoint).Address;
                    int ClientPort = (ReceiveSocket.RemoteEndPoint as IPEndPoint).Port;
                    int ReceiveLength = ReceiveSocket.Receive(result);
                    string str = ReceiveSocket.RemoteEndPoint.ToString();
                    string ReceiveMessage = Encoding.UTF8.GetString(result, 0, ReceiveLength);
                    richTextBox1.Text+= "接收客戶端:" + ReceiveSocket.RemoteEndPoint.ToString() +
                    "時間：" + DateTime.Now.ToString() + "\r\n" + "訊息：" + ReceiveMessage + "\r\n";
                    if (ClientInformation.Count == 1) continue;//只有一個客戶端
                    List<string> test = new List<string>(ClientInformation.Keys);
                    for (int i = 0; i < ClientInformation.Count; i++)
                    {
                        Socket socket = ClientInformation[test[i]];
                        string s = ReceiveSocket.RemoteEndPoint.ToString();
                        if (test[i] != s)
                        {
                            richTextBox1.Text += DateTime.Now + "\r\n" + "客戶端" + str + "向客戶端" + test[i] + "傳送訊息：" + ReceiveMessage;
                            string ReceiveMessage1 = DateTime.Now + "\r\n" + "客戶端" + str + "向您傳送訊息：" + ReceiveMessage;
                            socket.Send(Encoding.UTF8.GetBytes(ReceiveMessage1));
                        }
                    }
                }
                catch (Exception ex)
                {
                    richTextBox2.Text += "監聽出現異常！\r\n";
                    richTextBox2.Text += "客戶端" + ReceiveSocket.RemoteEndPoint + "已經連線中斷" + "\r\n" +
                    ex.Message + "\r\n" + ex.StackTrace + "\r\n";
                    string s = ReceiveSocket.RemoteEndPoint.ToString();
                    ClientInformation.Remove(s);
                    ReceiveSocket.Shutdown(SocketShutdown.Both);
                    ReceiveSocket.Close();
                    break;
                }
            }
        }
    }
}

介面效果：

注：我這裡在線列表顯示的是所有連線過伺服器的客戶端，對於可能出現的亂碼問題，將相應的ASCII改為UTF-8即可

新手我建議可以先看這兩位博主的文章：

https://www.cnblogs.com/vaevvaev/p/6865968.html

https://www.cnblogs.com/yy3b2007com/p/7476458.html

客戶端：

伺服器：

C#實現伺服器和客戶端之間通訊

TCP 套接字程式設計伺服器端實現步驟： 1、使用Socket類建立套接字。 2、利用Bind方法將建立的套接字繫結到指定的地址結構。 3、利用Listen方法設定套接字為監聽模式，使得伺服器進入被動開啟狀態。 4、接受客戶端的連線請求。 5、接收、應答客戶端的資料請求

java實現伺服器和客戶端之間的檔案傳輸

實現思路一、客戶端發文件：首先建立和伺服器的連線，然後我們通過IO流來實現資料的傳輸，步驟： 1、通過伺服器的IP地址和埠號實現和伺服器的連線（這裡不要忘記先開伺服器哦） 2、獲取本地的檔案的地址，建立java和檔案的連線。 3、獲取檔案輸入流和資料輸出流（注意：這裡的輸入和輸出都是指

在Android上實現SSL握手，實現伺服器和客戶端之間Socket互動

public class MySSLSocket extends Activity { private static final int SERVER_PORT = 50030;//埠號 private static final String SERVER_IP = "218.206.17

Java實現伺服器和客戶端簡單通訊

Java中網路程式設計這一塊有封裝的類庫，使用簡單，瞭解原理可以教容易實現伺服器和客戶端的簡單通訊。在程式設計之前，首先要需要對TCP/IP協議有一定的瞭解，需要知道Socket套接字的作用以及用法，這個可以在API文件中去檢視。兩通訊實體之間通訊需要掌握資

Socket通訊實現伺服器和客戶端對話

廣域網和區域網介紹socket通訊前我們先介紹一下廣域網與區域網的概念。區域網簡稱LAN，是指在某一區域幾臺計算機組成的計算機組，區域網是封閉的，區域網經常採用共享通道，即共用同一條電纜。廣域網簡稱WAN，是一種跨越大的，地域性的地區性網路集合廣域網包含大大小

socket實現客戶端和客戶端之間通訊和聊天

1.實體類 package edu.tcu.cn; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.Pr

nodejs+expressjs+ws實現了websocket即時通訊,伺服器和客戶端互相通訊

nodejs程式碼 // 匯入WebSocket模組: const WebSocket = require('ws'); // 引用Server類: const WebSocketServer = WebSocket.Server;

Vue+Java servlet 通過websocket實現伺服器與客戶端雙向通訊

1. vue程式碼 methods: { //在方法裡呼叫 this.websocketsend()傳送資料給伺服器 onConfirm () { //需要傳輸的資料 let data = { cod

網路程式設計伺服器和客戶端之間流的傳遞

import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; /* 實現TCP客戶端,連線到伺服器和伺服器

關於http和serverlet實現伺服器和客戶端的互動

Servlet的框架是由兩個Java包組成:javax.servlet和javax.servlet.http. 在javax.servlet包中定義了所有的Servlet類都必須實現或擴充套件的的通用介面和類.在javax.servlet.http包中定義了採用HTTP通訊協議的HttpServlet類.

使用python中的socket實現伺服器和客戶端，並完成圖片的傳輸

socket伺服器程式碼：import socket import os sk=socket.socket() print(sk) address=('127.0.0.1',8000) sk.bind(address) #將本地地址與一個socket繫結在一起sk.listen(3)

socket程式設計（一），實現伺服器與客戶端簡單通訊

本節主講客戶端向服務傳送資訊，伺服器轉發給客戶端，當然也可以稍微改一下程式碼可以實現互傳訊息，不再贅述。難點在於伺服器端的程式碼思路：（1）主程式Socket socket=server.acc

伺服器和客戶端之間互動時使用BufferedReader的阻塞問題

1.遇到的問題 Socket socket = serverSocket.accept(); BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()

使用python中的socket實現伺服器和客戶端，並完成圖片的傳輸。

socket伺服器程式碼：import socket import os sk=socket.socket() print(sk) address=('127.0.0.1',8000) sk.bind(address) #將本地地址與一個socket繫結在一起 sk.

在java網路程式設計中實現伺服器和客戶端一對一的聊天

如果有多個客戶端接入，都可以傳送訊息給伺服器，但伺服器只和最後一個客戶聊天。，如果要實現群聊的話，只要把所有的socket儲存到集合中，有客戶輸入時遍歷socket得到輸出流並把訊息廣播給各個客戶端就行了。四個讀寫的執行緒類都是一樣的，可以進行封裝，這裡就不封裝了。 Se

Redis伺服器和客戶端的通訊

Redis客戶端使用RESP（Redis序列化協議）與Redis伺服器進行通訊，RESP在位於TCP之上，而網路模型上客戶端和伺服器是保持的雙工的連線。如圖1 ![1587974695972](https://img2020.cnblogs.com/blog/1261088/202005/1261088-

linux下用多執行緒實現socket伺服器和客戶端的非同步通訊

前面介紹了用select函式來實現socket的非同步收發資料，但是select函式也有一些缺陷，要使socket能持續地通訊，select必須不停地檢測，這樣程序就會一直阻塞在這裡，限制了功能的擴充套件，這裡我們用多執行緒的方式，另建立兩個執行緒用來發送/接收

Python實現udp協議的簡單伺服器和客戶端通訊

簡單socket程式在兩臺電腦之間傳輸訊息，分為客戶端和服務端，分別在兩臺電腦上執行後即可進行簡單的訊息傳輸，也可以在一臺電腦上測試，設定兩個不同的埠即可以下是程式碼在一臺電腦上執行,開兩個終端即可

nodejs socket實現的服務端和客戶端簡單通訊

本文例項講述了通

1.SDL2_net TCP伺服器端和客戶端的通訊

這幾天打算把以前做的遊戲嘗試加入區域網聯機，恰巧SDL提供了對應的庫，即SDL2_net。 1.安裝我的系統是ubuntu，安裝相對簡單，下面一個命令即可： sudo apt install libsdl2-net-dev 等待安裝完成即可。如果使用的是window，可以去官

C#實現伺服器和客戶端之間通訊

相關推薦