C# Wie würde ich mich über mehrere Clients auf den gleichen Server zu verbinden?

Question

Ich bin auf einem Client-Server-Ende arbeiten und bin nicht allzu vertraut mit # .net und C, frage mich, wie ich über den Anschluss von mehreren Clients auf dem gleichen Server gehen. Würde es vorziehen, TcpClient weiter zu verwenden, wenn ich kann.

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; 
    using System.Net.Sockets; 
    using System.IO; 
    using Microsoft.VisualBasic; 
    using System.Runtime.Serialization.Formatters.Binary; 
    using System.Threading; 

    namespace TFServerClient 
    { 
     public partial class Form1 : Form 
    { 
     private TcpClient client; 
     public StreamReader STR; 
     public StreamWriter STW; 
     public string receive; 
     public String text_to_send; 
     TcpListener listener; 

    public Form1() 
    { 
     InitializeComponent(); 

     IPAddress[] localIP = Dns.GetHostAddresses(Dns.GetHostName()); //gets my IP 
     foreach(IPAddress address in localIP) 
     { 
      if(address.AddressFamily == AddressFamily.InterNetwork) 
      { 
       txtIPServer.Text = address.ToString(); 
      } 
     } 
    } 

    private void btnStartServer_Click(object sender, EventArgs e) 
    { 
     ListenBackground.RunWorkerAsync(); 
    } 

    private void ReceiveData_DoWork(object sender, DoWorkEventArgs e) 
    { 
     while(client.Connected) 
     { 
      try 
      { 
       receive = STR.ReadLine(); 
       this.txtChat.Invoke(new MethodInvoker(delegate() { txtChat.AppendText("You: " + receive + "\n"); })); 
       receive = ""; 
      } 
      catch (Exception x) 
      { 
       MessageBox.Show(x.Message.ToString()); 
      } 
     } 
    } 

    private void SendData_DoWork(object sender, DoWorkEventArgs e) 
    { 
     if(client.Connected) 
     { 
      STW.WriteLine(text_to_send); 
      this.txtChat.Invoke(new MethodInvoker(delegate() { txtChat.AppendText("Me: " + text_to_send + "\n"); })); 
     } 
     else 
     { 
      MessageBox.Show("Send failed"); 
     } 
     SendData.CancelAsync(); 
    } 

    private async void ListenBackground_DoWork(object sender, DoWorkEventArgs e) 
    { 
     this.txtChat.Invoke(new MethodInvoker(delegate() { txtChat.AppendText("Awaiting Connection...\n"); })); 
     client = listener.AcceptTcpClient(); 
     this.txtChat.Invoke(new MethodInvoker(delegate() { txtChat.AppendText("Client Connected.\n"); })); 
     STR = new StreamReader(client.GetStream()); 
     STW = new StreamWriter(client.GetStream()); 
     STW.AutoFlush = true; 

     ReceiveData.RunWorkerAsync(); //Start recieving data in background 
     SendData.WorkerSupportsCancellation = true; //able to cancel thread 
    } 

    private void btnConnect_Click(object sender, EventArgs e) 
    { 
     client = new TcpClient(); 
     IPEndPoint IP_End = new IPEndPoint(IPAddress.Parse(txtIPClient.Text), int.Parse(txtPortClient.Text)); 

     try { 
      client.Connect(IP_End); 
      if(client.Connected) 
      { 
       txtChat.AppendText("Connected To Server " + "\n"); 
       STW = new StreamWriter(client.GetStream()); 
       STR = new StreamReader(client.GetStream()); 
       STW.AutoFlush = true; 

       ReceiveData.RunWorkerAsync(); //Start recieving data in background 
       SendData.WorkerSupportsCancellation = true; //able to cancel thread 
      } 
     } catch(Exception x) 
     { 
      MessageBox.Show(x.Message.ToString()); 
     } 
    } 

    private void btnSend_Click(object sender, EventArgs e) 
    { 
     if(txtMessage.Text != "") 
     { 
      text_to_send = txtMessage.Text; 
      SendData.RunWorkerAsync(); 
     } 
     txtMessage.Text = ""; 
    } 
} 
} 

Answer 1

Es gibt eine wirklich nette freie lib namens NetSockets, die Sie dafür verwenden können. (https://netsockets.codeplex.com/) < die lib zum Download bereit.

Die lib ist TCP und multi-threaded, hier ist, wie es zu benutzen:

• Server Side:

den Server erstellen:

static NetObjectServer server = new NetObjectServer(); 

Starten des Servers:

server.Start(IPAddress.Any, 7482); 

Event-Handler:

server.OnClientAccepted += server_OnClientAccepted; 

server.OnClientConnected += server_OnClientConnected; 

server.OnClientDisconnected += server_OnClientDisconnected; 

server.OnClientRejected += server_OnClientRejected; 

server.OnReceived += server_OnReceived; 

server.OnStarted += server_OnStarted; 

server.OnStopped += server_OnStopped; 

• Client Side:

Erstellen des Clients:

static readonly NetObjectClient client = new NetObjectClient(); 

Event-Handler:

client.OnConnected += client_OnConnected; 

client.OnDisconnected += client_OnDisconnected; 

client.OnReceived += client_OnReceived; 

Connect ing:

client.TryConnect("127.0.0.1",7482); 

Diese Information von Joseph Bisaillon Blog genommen wurde (http://www.josephbisaillon.com/)

Answer 2

Es klingt wie Sie müssen einfach Ihren serverseitigen Code, ähnlich den folgenden-multithread:

listener = new TcpListener(ipAddress, portNumber); 
listener.Start(); 

while (true) 
{ 
    var client = listener.AcceptTcpClient(); 
    var thread = new Thread(new ThreadStart(() => SOME ACTION)); 
} 

der Delegierte Sie den Threadstart-Konstruktor in wird die Schaffung Stream Leser und Stromschreiber behandeln. Es sollte auch jede serverseitige Geschäftslogik ausführen, die Sie ausführen möchten.

Die AcceptTcpClient Methode ist eine blockierende Methode, also eine neue Thread-Instanz wird nur jedes Mal gibt es eine TCP-Anforderung von einem Client empfangen erstellt werden.

Beispiele für diese Art von Aktion finden Sie hier:

Here bei csharp.net-informations.com

Here bei codeproject.com

Warnung: Durch Betrachten Downloads mit den zugehörigen Artikel bei codeproject.com stimmen Sie den Nutzungsbedingungen und der Lizenz des Artikels zu.Die Lizenz ist die Code Project Open-Lizenz (CPOL)