System.Net.Sockets, hvordan går jeg frem?

[Stig Jøran]

Heisann.

 

Har skrevet et lite chatteprogram før i vb 6.0 med winsock der.

Problemet er at jeg ikke husker så alltformye fra det, men nå tenkte jeg å prøve meg på VB 2005 Express. Og da bruke .NET Sockets, men så er spm.

 

Slik jeg gjorde det i vb6.0 bruker jeg 2 sockets, en som sendte å en som mottok.

Men får følelsen av at det er litt verre i vb 2005.

 

Hvor skal jeg starte? Har sett litt rundt på MSDN, men klarer ikke helt å finne ut av hva jeg trenger. Alt jeg er ute etter er 2 programmer som snakker sammen. Altså ikke noe Server med flere Clienter.

[wolf5]

Er ikke så vanskelig når du først har gjort det en gang. Her har jeg en kode jeg mekket.

 

Server

       MySocketsServer ss = new MySocketsServer();
       void TestServer() {
           ss.OnDataArrival += new MySocketsServer.DataArrivalHandler(ss_OnDataArrival);
           ss.Serve(5000);

       }

       void ss_OnDataArrival(string data, string remoteID) {
           Debug.WriteLine("Klient sendte: " + data);
           if (data == "KOMMANDO_01") ss.Send(remoteID, "Du sendte en gyldig kommando!");
       }

 

Klient

       MySocketsClient sc = new MySocketsClient();
       void TestKlient() {
           sc.OnDataArrival += new MySocketsClient.DataArrivalHandler(sc_OnDataArrival);
           sc.Connect("localhost:5000");
           
           sc.Send("God dagen, server");

           sc.Send("KOMMANDO_01");
       }

       void sc_OnDataArrival(string data, string remoteID) {
           Debug.WriteLine("Server sendte: " + data);
       }

 

Socket Klient

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.ComponentModel;
using System.Threading;
using System.Diagnostics;

namespace TestWebBrowserControl {

   class MySocketsClient {
       private Socket s = null;
       private BackgroundWorker listener = null;
       private bool IsConnected = false;
       private string ServerIPPort = "";

       public bool DebugInputOutput = false;

       public MySocketsClient() {
           listener = new BackgroundWorker();
           listener.DoWork += new DoWorkEventHandler(listener_DoWork);
           listener.ProgressChanged += new ProgressChangedEventHandler(listener_DataArrival);
           listener.RunWorkerCompleted += new RunWorkerCompletedEventHandler(listener_RunWorkerCompleted_Disconnect);
           listener.WorkerReportsProgress = true;
       }

       #region Events
       /// <summary>
       /// Delegat for OnDataArrival
       /// </summary>
       public delegate void DataArrivalHandler(string data, string remoteID); //Delegaten som brukes til DataArrival
       /// <summary>
       /// Delegat for OnDisconnect
       /// </summary>
       public delegate void DisconnectHandler(string remoteID); //Delegaten som brukes til Disconnect
       /// <summary>
       /// Delegat for OnConnect
       /// </summary>
       public delegate bool ConnectHandler(string remoteID); //Delegaten som brukes til ny Connection

       public event DataArrivalHandler OnDataArrival = null;
       public event DisconnectHandler OnDisconnect = null;
       #endregion

       public void Connect(string ServerIPColonPort) {
           string ServerIP = ServerIPColonPort.Split(':')[0];
           int ServerPort = Convert.ToInt32(ServerIPColonPort.Split(':')[1]);
           Connect(ServerIP, ServerPort);
       }

       public void Connect(string ServerIP, int ServerPort) {
           IPEndPoint ipe = null;//new IPEndPoint(IPAddress.Parse(serverip), serverport);

           try {
               int number = 0;
               if (Int32.TryParse(ServerIP.Substring(0, 1), out number)) {
                   //IP number
                   ipe = new IPEndPoint(IPAddress.Parse(ServerIP), Convert.ToInt32(ServerPort));
               } else {
                   //DNSName
                   IPHostEntry iphe = Dns.GetHostEntry(ServerIP);
                   ipe = new IPEndPoint(iphe.AddressList[0], Convert.ToInt32(ServerPort));
               }
           } catch {
               Console.WriteLine("Illegal server/port... Ignoring.");
               return;
           }

           ServerIPPort = ipe.Address.ToString() + ":" + ServerPort.ToString();

           while (listener.IsBusy) {
               Debug.WriteLine("Waiting for old bg job to be done1.");
               Thread.Sleep(500);
           }

           s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
           while (true) {
               try {
                   s.Connect(ipe);
               } catch (Exception ex) {
                   if (ex.Message.StartsWith("Cannot access a disposed object")) {
                       Thread.Sleep(1000);
                       s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                       continue;
                   }
                   if (ex.Message.StartsWith("An operation was attempted on something that is not a socket")) {
                       Thread.Sleep(1000);
                       s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                       continue;
                   }

                   throw ex;
               }
               break;
           }
           IsConnected = true;
           while (listener.IsBusy) {
               Debug.WriteLine("Waiting for old bg job to be done1.");
               Thread.Sleep(500);
           }
           listener.RunWorkerAsync(s);

       }

       List<byte> IncData = new List<byte>();
       void listener_DataArrival(object sender, ProgressChangedEventArgs e) {
           DataInfo di = e.UserState as DataInfo;
           if (DebugInputOutput) Debug.WriteLine("<<" + System.Text.Encoding.Default.GetString(di.data));
           if (OnDataArrival != null) {
               OnDataArrival(System.Text.Encoding.Default.GetString(di.data), ServerIPPort);
           } else {
               lock (IncData) IncData.AddRange(di.data);
           }
       }

       /// <summary>
       /// Returns received data so far
       /// </summary>
       /// <returns></returns>
       public string GetData() {
           string data = "";
           lock (IncData) {
               data = System.Text.Encoding.Default.GetString(IncData.ToArray());
               IncData = new List<byte>();
           }
           return data;
       }

       /// <summary>
       /// Waits for data to return
       /// </summary>
       /// <returns></returns>
       public string WaitData() {
           while (IncData.Count == 0) {
               Thread.Sleep(5);
           }

           string data = "";
           lock (IncData) {
               data = System.Text.Encoding.Default.GetString(IncData.ToArray());
               IncData = new List<byte>();
           }
           return data;
       }

       private class DataInfo {
           public byte[] data;
       }

       //public bool CheckForNewLines = true;

       void listener_DoWork(object sender, DoWorkEventArgs e) {
           Socket mysock = e.Argument as Socket;
           int i = 0;


           while (IsConnected && mysock.Connected) {
               DataInfo di = new DataInfo();

               byte[] buffer = new byte[mysock.ReceiveBufferSize];
               List<byte> lbuff = new List<byte>();

               while (mysock.Connected && mysock.Poll(0, SelectMode.SelectRead) && mysock.Connected) { //checking if data ends on \n
                   if (mysock.Connected && mysock.Available > 0) {
                       //do {
                       int c = mysock.Receive(buffer);
                       if (!mysock.Connected) return;
                       di.data = new byte[c];
                       byte[] receiveData = new byte[c];
                       Buffer.BlockCopy(buffer, 0, receiveData, 0, c);
                       lbuff.AddRange(receiveData); //Gather the data till there is no more data coming
                       //} while (CheckForNewLines && lbuff.Count > 0 && lbuff[lbuff.Count - 1] != 10); //Make sure data ends on '\n'
                   } else {
                       IsConnected = false;
                       break;
                   }
                   if (!mysock.Connected) return;
               }
               if (!mysock.Connected) return;
               if (lbuff.Count > 0) {
                   //Send data to handlers
                   di.data = lbuff.ToArray();
                   lbuff.Clear();
                   if (!mysock.Connected) return;
                   listener.ReportProgress(i, di);
                   if (!mysock.Connected) return;
                   i++;
               }
               Thread.Sleep(1);
           }

       }

       void listener_RunWorkerCompleted_Disconnect(object sender, RunWorkerCompletedEventArgs e) {
           Disconnect();

       }

       public void Disconnect() {
           string tmp = "";
           lock (ServerIPPort) {
               tmp = ServerIPPort;
               ServerIPPort = "";
           }
           if (tmp.Length > 0) {
               if (OnDisconnect != null) OnDisconnect(tmp);
               IsConnected = false;
               try {
                   s.Close();
               } catch {
               }
           }
       }

       public void Send(string data) {
           if (s.Connected) {
               if (DebugInputOutput) Debug.WriteLine(">>" + data);
               try {
                   if (s.Connected) s.Send(System.Text.Encoding.Default.GetBytes(data));
               } catch (Exception) {
               }
           } else {
               if (DebugInputOutput) Debug.WriteLine("Did not send >>" + data);
           }
       }

       public void Send(byte[] data) {
           if (s.Connected) {
               if (DebugInputOutput) Debug.WriteLine(">>" + System.Text.Encoding.Default.GetString(data));
               try {
                   if (s.Connected) s.Send(data);
               } catch (Exception) {
               }
           } else {
               if (DebugInputOutput) Debug.WriteLine("Did not send >>" + System.Text.Encoding.Default.GetString(data));

           }
       }


   }
}

 

Socket Server

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.ComponentModel;
using System.Threading;
using System.Diagnostics;

namespace TestWebBrowserControl {

   class MySocketsServer {
       private BackgroundWorker listener = null;
       private BackgroundWorker connectionlistener = null;
       private bool IsConnected = false;
       private string ServerIPPort = "";

       public bool DebugInputOutput = false;

       public MySocketsServer() {
           listener = new BackgroundWorker();
           listener.DoWork += new DoWorkEventHandler(listener_DoWork);
           //listener.ProgressChanged += new ProgressChangedEventHandler(listener_DataArrival);
           //listener.RunWorkerCompleted += new RunWorkerCompletedEventHandler(listener_RunWorkerCompleted_Disconnect);
           //listener.WorkerReportsProgress = true;
           connectionlistener = new BackgroundWorker();
           connectionlistener.DoWork += new DoWorkEventHandler(connectionlistener_DoWork);
       }


       #region Events
       /// <summary>
       /// Delegat for OnDataArrival
       /// </summary>
       public delegate void DataArrivalHandler(string data, string remoteID); //Delegaten som brukes til DataArrival
       /// <summary>
       /// Delegat for OnDisconnect
       /// </summary>
       public delegate void DisconnectHandler(string remoteID); //Delegaten som brukes til Disconnect
       /// <summary>
       /// Delegat for OnConnect
       /// </summary>
       public delegate bool ConnectHandler(string remoteID); //Delegaten som brukes til ny Connection

       public event DataArrivalHandler OnDataArrival = null;
       public event DisconnectHandler OnDisconnect = null;
       #endregion

       BackgroundWorker bgwListener = null;
       public void Serve(int Port) {
           Socket s = null;
           if (s == null) {
               s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
           }

           IPEndPoint ipEP = new IPEndPoint(IPAddress.Any, Port);
           try {
               s.Bind(ipEP);
           } catch (Exception ex) {
               throw new Exception("Bind feilet: [Exception:" + ex.GetType().ToString() + ", " + ex.Message + "]");
           }

           s.Listen(1000);
           s.Blocking = true;

           listener.RunWorkerAsync(s);
           connectionlistener.RunWorkerAsync(s);
       }

       bool bDone = false;


       //List<byte> IncData = new List<byte>();
       //void listener_DataArrival(object sender, ProgressChangedEventArgs e) {
       //    DataInfo di = e.UserState as DataInfo;
       //    if (DebugInputOutput) Debug.WriteLine("<<" + System.Text.Encoding.Default.GetString(di.data));
       //    if (OnDataArrival != null) {
       //        OnDataArrival(System.Text.Encoding.Default.GetString(di.data), ServerIPPort);
       //    } else {
       //        lock (IncData) IncData.AddRange(di.data);
       //    }
       //}

       ///// <summary>
       ///// Returns received data so far
       ///// </summary>
       ///// <returns></returns>
       //public string GetData() {
       //    string data = "";
       //    lock (IncData) {
       //        data = System.Text.Encoding.Default.GetString(IncData.ToArray());
       //        IncData = new List<byte>();
       //    }
       //    return data;
       //}

       ///// <summary>
       ///// Waits for data to return
       ///// </summary>
       ///// <returns></returns>
       //public string WaitData() {
       //    while (IncData.Count == 0) {
       //        Thread.Sleep(5);
       //    }

       //    string data = "";
       //    lock (IncData) {
       //        data = System.Text.Encoding.Default.GetString(IncData.ToArray());
       //        IncData = new List<byte>();
       //    }
       //    return data;
       //}

       //private class DataInfo {
       //    public byte[] data;
       //}

       private bool SockConnected(Socket s) {
           bool f = s.Poll(1, SelectMode.SelectRead);
           if (f == true && s.Available == 0) {
               return false;
           }
           return true;
       }

       //Venter på connections
       void connectionlistener_DoWork(object sender, DoWorkEventArgs e) {
           Socket mainsock = e.Argument as Socket;
           //Sjekk etter nye connections
           while (!bDone) {
               try {
                   Socket newsock = mainsock.Accept();
                   sockets.Add(newsock.RemoteEndPoint.ToString(), newsock);
               } catch (Exception) {
                   System.Threading.Thread.Sleep(100);
               }
           }

       }

       //public bool CheckForNewLines = true;
       Dictionary<string, Socket> sockets = new Dictionary<string, Socket>();
       void listener_DoWork(object sender, DoWorkEventArgs e) {
           Socket mainsock = e.Argument as Socket;
           int i = 0;
           while (!bDone) {
               //Sjekk for status og data på eksisterende connections
           rerun:
               foreach (KeyValuePair<string, Socket> kvp in sockets) {
                   Socket clientsock = kvp.Value;
                   if (!SockConnected(clientsock)) {
                      //DISCONNECT EVENT
                       Disconnect(kvp.Key);
                       sockets.Remove(kvp.Key);
                       OnDisconnect(kvp.Key);
                       goto rerun;
                   }
                   bool bNewdata = false;
                   List<byte> data = new List<byte>();
                   byte[] buffer = new byte[8192];
                   while (clientsock.Available > 0) {
                       bNewdata = true;
                       int c = clientsock.Receive(buffer);
                       data.AddRange(buffer);
                   }
                   if (bNewdata) {
                       //DataArrived EVENT
                       string retvalue = System.Text.Encoding.Default.GetString(data.ToArray());
                       if (OnDataArrival != null) OnDataArrival(retvalue, kvp.Key);
                   }

               }
               Thread.Sleep(50);
           }

           //while (IsConnected && mysock.Connected) {
           //    DataInfo di = new DataInfo();

           //    byte[] buffer = new byte[mysock.ReceiveBufferSize];
           //    List<byte> lbuff = new List<byte>();

           //    while (mysock.Connected && mysock.Poll(0, SelectMode.SelectRead) && mysock.Connected) { //checking if data ends on \n
           //        if (mysock.Connected && mysock.Available > 0) {
           //            //do {
           //            int c = mysock.Receive(buffer);
           //            if (!mysock.Connected) return;
           //            di.data = new byte[c];
           //            byte[] receiveData = new byte[c];
           //            Buffer.BlockCopy(buffer, 0, receiveData, 0, c);
           //            lbuff.AddRange(receiveData); //Gather the data till there is no more data coming
           //            //} while (CheckForNewLines && lbuff.Count > 0 && lbuff[lbuff.Count - 1] != 10); //Make sure data ends on '\n'
           //        } else {
           //            IsConnected = false;
           //            break;
           //        }
           //        if (!mysock.Connected) return;
           //    }
           //    if (!mysock.Connected) return;
           //    if (lbuff.Count > 0) {
           //        //Send data to handlers
           //        di.data = lbuff.ToArray();
           //        lbuff.Clear();
           //        if (!mysock.Connected) return;
           //        listener.ReportProgress(i, di);
           //        if (!mysock.Connected) return;
           //        i++;
           //    }
           //    Thread.Sleep(1);
           //}

       }

       void listener_RunWorkerCompleted_Disconnect(object sender, RunWorkerCompletedEventArgs e) {

           Disconnect(null);

       }

       public void Disconnect(string Client) {
           Socket s = sockets[Client];
           //s.Disconnect(false);
           s.Close();
       }

       public void Send(string Client, string data) {
           Socket s = sockets[Client];
           if (s.Connected) {
               if (DebugInputOutput) Debug.WriteLine(">>" + data);
               try {
                   if (s.Connected) s.Send(System.Text.Encoding.Default.GetBytes(data));
               } catch (Exception) {
               }
           } else {
               if (DebugInputOutput) Debug.WriteLine("Did not send >>" + data);
           }
       }

       public void Send(string Client, byte[] data) {
           Socket s = sockets[Client];
           if (s.Connected) {
               if (DebugInputOutput) Debug.WriteLine(">>" + System.Text.Encoding.Default.GetString(data));
               try {
                   if (s.Connected) s.Send(data);
               } catch (Exception) {
               }
           } else {
               if (DebugInputOutput) Debug.WriteLine("Did not send >>" + System.Text.Encoding.Default.GetString(data));

           }
       }


   }
}