Konvertere 6.0 socket til .net klasse

[Gjakmarrja]

Hei!

 

Jeg har brukt en klasse jeg fant i mine 6.0 proskjekter da det er en genial kopi av den orginale winsock kontrollen.

(Jeg har ikke laget den)

Dette heter da:

CSocketMaster og er laget i 6.0

 

LINK

 

Ser ut som forfatteren/koderen har gitt opp dette proskjekte for lengst, da jeg håper om folk her kunne tenke seg å lage dette om så vi alle kan dra nytte av det.

 

Dette jobber direkte opp mot sockets API i windows, akkurat det samme som sockets klassen i .NET gjør.

Bare dette gir deg en form for winsock kontroll over sockets, noe som er mye enklere å bruke. Ikke fullt så avansert men utrolig mye enklere.

Da jeg tenker på enklere chatte program og slikt.

 

Noen som er dyktig til akkurat dette, hvis du vet hva du gjør skal det ikke ta lang tid

å konvertere dette.

 

Vet jeg ber om ekstremt mye her, da jeg vet at Manfred (bruker her på forumet) kommer til å be meg om å dra et vist sted grunnet mengden av det jeg ber om.

 

Hvis ingen orker, får jeg vel heller bare starte på .NET sockets eller skrive en klasse

fra scracth av.

 

Er også interesser hvis folk har link til noe som minner om dette her?

 

Takker for hjelp.

[aadnk]

Ærlig talt ser jeg ikke nytteverdien for å konvertere, eller i praksis skrive den på nytt, til .NET. Især ikke når .NET har brukbare klasser for akkurat dette formålet. Det er faktisk bedre at du bruker .NET-rammeverket til sitt fulle.

 

Om du likevel har lyst til å benytte en Winsock-liknende kontroll, kan du jo ganske enkelt refererere til COM-objektet i .NET (Add Reference -> COM).

[wolf5]

Her har du en Socket klasse jeg lagde ifm å lage en MSN procol 9 bibliotek:

 

Den pakker inn .Net sin socket pakke i noe som likner hva winsock gjorde. Det vil si at bare connecter, sender meldinger og retur kommer til callback funksjoner du definerer.

 

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 TempSocketsTest {
   class MySockets {
       private Socket s = null;
       private BackgroundWorker listener = null;
       private bool IsConnected = false;
       private string ServerIPPort = "";

       public bool DebugInputOutput = false;

       public MySockets() {
           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));

           }
       }


   }
}

 

Eksempel kode som vil gi deg maaange popup meldinger fra vg.no

(den henter www.vg.no sin webside)

using System;
using System.Collections.Generic;
using System.Windows.Forms;


namespace TempSocketsTest {
   static class Program {
       static MySockets ms = new MySockets();

       [STAThread]
       static void Main() {
           ms.OnDataArrival += new MySockets.DataArrivalHandler(ms_OnDataArrival);
           ms.OnDisconnect += new MySockets.DisconnectHandler(ms_OnDisconnect);
           ms.Connect("www.vg.no:80");

           string HTTPGetStreng =
                 "GET http://www.vg.no/ HTTP/1.0" + "\r\n"
               + "Accept: */*" + "\r\n"
               + "Accept-Language: no" + "\r\n"
               + "User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727)" + "\r\n"
               + "Host: www.vg.no" + "\r\n"
               + "Proxy-Connection: Keep-Alive" + "\r\n" + "\r\n";
           ms.Send(HTTPGetStreng);

           Application.Run();
       }

       static void ms_OnDisconnect(string remoteID) {
           MessageBox.Show("Mast forbindelse til " + remoteID);
       }

       static void ms_OnDataArrival(string data, string remoteID) {
           MessageBox.Show(remoteID + " sendte: " + data);
       }
   }
}

Endret 20. juni 2006 av wolf5

[Gjakmarrja]

Så veldig bra ut.