TcpClient et TcpListener une est dérivée l'autre incluse dans une clas

Question

Bonjour,
je commence à pété un cable car je ne comprend pas trop ce qui ce passe alors voici les deux sources et un bout de code de l'appli.
Si qqn a une idée ou une critique tt est bien venue ;).
Merci d'avance.

public class DCTcpClient:TcpClient
{
//Evenement et Handler
public class TcpEvent:EventArgs
{
private DCTcpClient _clt;
private int _nbrecu;
public byte[] buffer;

public TcpEvent(DCTcpClient sockclt,byte[] recu,int nbrecu)
{
this._clt = sockclt;
this.buffer = recu;
this._nbrecu = nbrecu;
}

public TcpEvent(DCTcpClient sockclt)
{
this._clt = sockclt;
}

public DCTcpClient DCClient
{
get
{
return this._clt;
}
}

public int SizeRecu
{
get
{
return this._nbrecu;
}
}
}

public delegate void TcpCltEventHandler (object sender,TcpEvent te);
public event TcpCltEventHandler On_Receive;

//Propriétés
private AsyncCallback	acb;
private byte[]			rbuffer;
private byte[]			sbuffer;
private bool			_etat;
private NetworkStream	_NS;
private IPAddress		_IP;
private int				_port = -1;

//Méthodes et constructeurs
public DCTcpClient():base()
{
Initialize();
}

public DCTcpClient(string Host,int port):base(Host,port)
{
IPHostEntry iphost = Dns.Resolve(Host);
this._IP = iphost.AddressList[0];
this._port = port;
Initialize();
}

public DCTcpClient(Socket s)
{
this.Sock = s;
Initialize();
}

public void Connecter()
{
if(this._IP != null && this._port > -1)
{
try
{
this.Connect(new IPEndPoint(this._IP,this._port));
this._NS = this.GetStream();
this.Etat = true;
}
catch(SocketException se)
{
throw se;
}
}
}

public void Connecter(string Host,int port)
{
IPHostEntry iphost = Dns.GetHostByAddress(Host);;
_IP = iphost.AddressList[0];
_port = port;
if(this._IP != null && this._port > -1)
{
try
{
this.Connect(Host,port);
this._NS = this.GetStream();
this.Etat = true;
}
catch(SocketException se)
{
throw se;
}
}
}

private void Initialize()
{
this._etat = false;
this.rbuffer = new byte[4096];
this.sbuffer = new byte[4096];
this.ReceiveBufferSize = 4096;
this.SendBufferSize = 4096;
}

private void Receive(IAsyncResult iar)
{
DCTcpClient temp = (DCTcpClient)iar.AsyncState;
int size = temp.Client.EndReceive(iar);
if(size > 0)
{
this.On_Receive(this,new TcpEvent(this,this.rbuffer,size));
this.BeginAsyncRead();
}
else
{
this.Etat = false;
this.Client.Close();
}
}

public void BeginAsyncRead()
{
acb = new AsyncCallback(this.Receive);
this.Client.BeginReceive(this.rbuffer,0,this.rbuffer.Length,SocketFlags.None ,acb,this);
}

public string ReceiveBuffer
{
get
{
return System.Text.Encoding.Default.GetString(this.rbuffer);
}
set
{
string temp = value;
if(temp.Equals(""))
{
this.rbuffer = new byte[4096];
}
}
}

public string Response
{
set
{
this.Sock.Send(System.Text.Encoding.Default.GetBytes(value));
}
}

public byte[] bResponse
{
set
{
this.Sock.Send(value);
}
}

public Socket Sock
{
get
{
return this.Client;
}
set
{
this.Client = value;
}
}

public bool Etat
{
get
{
return this._etat;
}
set
{
this._etat = value;
}
}

public override string ToString()
{
return this._IP.ToString();
}
}

"Un joli code de barbare :) puis un autre"

public class DCTcpListener
{
public delegate void TcpListenerHandler(object sender,TcpListenerEvent tle);
public event TcpListenerHandler On_Connect;

public class TcpListenerEvent : EventArgs
{
private Socket _s;

public TcpListenerEvent(Socket s)
{
this._s = s;
}

public Socket Sock
{
get
{
return this._s;
}
}
}

private TcpListener _serveur;
private Thread		_th;
private bool		_alive;

public DCTcpListener(int port)
{
this._serveur = new TcpListener(port);
this._th = new Thread(new ThreadStart(this.Ecoute));
this.Alive = true;
_th.Start();
}

public bool Alive
{
get
{
return this._alive;
}
set
{
this._alive = value;
}
}

private void Ecoute()
{
this._serveur.Start();
while(this.Alive)
{
if(this._serveur.Pending())
{
this.On_Connect(this,new TcpListenerEvent(this._serveur.AcceptSocket()));
}
}
this._serveur.Stop();
this._th.Abort();
this._th = null;
}
}

"Et le bout de code"

Dans un formulaire banal:
...
private void button2_Click(object sender, System.EventArgs e)
{
tempclt = new DC__.DCTcpClient();
tempclt.On_Receive += new DC__.DCTcpClient.TcpCltEventHandler(this.Receive);
this.Serveur = new DCTcpListener(411);
this.Serveur.On_Connect += new DCTcpListener.TcpListenerHandler(this.ConnectionPend);
}

private void ConnectionPend(object sender,DCTcpListener.TcpListenerEvent tle)
{
tempclt.Sock = tle.Sock;
tempclt.Sock.Send(System.Text.Encoding.Default.GetBytes(DC__.ProtoDC.CreateLock()));
}

private void Receive(object sender,DC__.DCTcpClient.TcpEvent te)
{
MessageBox.Show(te.DCClient.ReceiveBuffer);
//te.DCClient.Sock.Send(te.buffer);
}
...

En fait si ce que je veux faire marche, un client demande une connection qui lève l'événement ConnectionPend.
Ensuite, j'initialise le socket de mon objet tempclt(DCTcpClient) et rajoute un handler sur l'événement On_Receive qui pointe sur la fonction Receive. Oula quel bordel dans les explications!!
L'événement Receive devrait être levé lorsque mon client distant (ce qui fonctionne très bien si c l'objet tempclt qui se connecte sur un Hote distant) envoit qqc mais non il veut pas le monsieur et comprend pas bien ce qui peut le traumatiser.

Trollien (comme le pseudo l'indique jsuis un barbar dans mes codes)

Trollien · Answer

En fait c bon, j'ai trouvé une source nickel chrome.
Qui utilise la classe Socket plutot que les TcpMachin.
Ce qui permet un controle plus vaste.
Merci.

TcpClient et TcpListener une est dérivée l'autre incluse dans une clas

1 réponse

Votre réponse

Discussions similaires