c# Socket Problem

[finalmove]

Hallo zusammen,

ich hoffe Ihr könnt mir helfen.
Also gut ich habe eine Client Server anwendung geschrieben in C#.
Die ganze Socket Kommunikatino läuft Asynchron. Das Porblem tritt nun auf,
wenn ich meine Socket Kommunikation Per Click auf einen Stop knopf beenden will und nach einem Click auf Start wieder aufnehmen möchte.
Das ganze Problem sowie ich meine liegt am Socket.Shutdown befehl.
Ich führe erst den Socket.Shutdown aus und dann mache ich Socket.Close.
Wenn ich nun das Programm beende, läuft aber Trotzdem noch was.
Wenn ich dann so ca. 5-10 sekunden warte ist das Programm aus.
Ich denke mal das ist der Garbage collector der dann das geschlossene Socketobjekt aus dem Speicher schmeißt. Auserdem funktioniert der Socket.Shutdown nich, die Exception gibt immer folgende meldung aus:

Eine Anforderung zum Senden oder Empfangen von Daten wurde verhindert, da der Socket nicht verbunden ist und (beim Senden über einen Datagrammsocket mit einem sendto-Aufruf) keine Adresse angegeben wurde

Hier der SourceCode

using System;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace SSIM2
{
	/// <summary>
	/// Zusammenfassung für SocketCommunicationComponent.
	/// Abgeleitet von AbstractCommunicationComponent
	/// </summary>
	[Serializable]
	public class SocketCommunicationComponent : AbstractCommunicationComponent
	{
		private Socket listenSocket = null;			//Listen-Socket
		private Socket clientSocket = null;			//Client-Socket
//		private Socket listenclient = null;			//Client-Socket

		private Thread m_rec_thread;				//Thread der den listenSocket verwendet und auf antwort vom kopller lauscht
		private Thread m_send_thread;				//Thread der zum senden der Telegramme verwendet wird
		private IPEndPoint endpoint;				//Remoteendpoint wohin soll sich der server verbindne

		//___________________Konstanten füe die Werte_________________
		public static readonly string REMOTE_IP = "REMOTE_IP";
		public static readonly string REMOTE_PORT = "REMOTE_PORT";		//44445
		public static readonly string LOCAL_PORT = "LOCAL_PORT";		//44444

		//___________________Array mit benötigten werten______________
		private static readonly string[] allowedkeys = new string[]		{REMOTE_IP,REMOTE_PORT,LOCAL_PORT};

		public new delegate void FactorialCompleteHandler(Telegramm t);
		public new event FactorialCompleteHandler FactorialComplete;

		public override void start()
		{
			base.start ();
			//________________________Socket-Server________________________________

			// Listen-Socket erzeugen und auf Lauschposten setzen
			try 
			{
				try
				{
					this.listenSocket.Close();
				}
				catch(Exception e)
				{
					Console.WriteLine(e.Message);
				}
					// erzeugen
				this.listenSocket = new Socket(AddressFamily.InterNetwork, 
					SocketType.Stream, 
					ProtocolType.Tcp);

				// binden
				this.listenSocket.Bind(endpoint);

				// Listen-Modus mit maximaler Anzahl Clients
				this.listenSocket.Listen(100);

			}	// try Socket-Erzeugung
			catch (Exception ex)
			{
				Console.WriteLine("Fehler in SocketCommunicationComponent --> ListenSocket: \n " + ex.Message);
			}

			//_______________________Ende-Socket-Server______________________________
			try
			{

				m_status = AbstractCommunicationComponent.DISCONNECTED;
				//_______________________Socket-Client___________________________________

				//erstellen eines sockets ...
				this.clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

				String szIPSelected  = this.Parameter[REMOTE_IP].ToString();
				int  alPort = Convert.ToInt32(this.Parameter[REMOTE_PORT]);

				System.Net.IPAddress	remoteIPAddress	 = System.Net.IPAddress.Parse(szIPSelected);
				System.Net.IPEndPoint	remoteEndPoint = new System.Net.IPEndPoint(remoteIPAddress, alPort);
				//Verbindung herstellen...
				clientSocket.Connect(remoteEndPoint);
				m_status = AbstractCommunicationComponent.CONNECTED;
				//_______________________Ende-Socket-Client______________________________

				// create threads
				m_rec_thread = new Thread(new ThreadStart(this.receiveThread));
				m_rec_thread.Name="Empfangsthread";
				m_rec_thread.Start();
			}
			catch
			{
				m_status = AbstractCommunicationComponent.DISCONNECTED;
			}
		}

		/// <summary>
		/// Get the new data and send it out to all other connections. 
		/// Note: If not data was recieved the connection has probably 
		/// died.
		/// </summary>
		/// <param name="ar"></param>
		public void OnRecievedData( IAsyncResult ar )
		{
			SocketClient client = (SocketClient)ar.AsyncState;
			byte [] aryRet = client.GetRecievedData( ar );
			if(this.m_running == true)
			{
				// If no data was recieved then the connection is probably dead
				if( aryRet.Length < 1 )
				{
					Console.WriteLine( "Client {0}, disconnected", client.Sock.RemoteEndPoint );
					Thread.Sleep(250);
					//client.Sock.Close();    				
					//return;
				}
				else
				{
					//string inData		= .ToString();						// Client-Anfrage als String
					m_status = AbstractCommunicationComponent.CONNECTED;	//setzt den Verbindungsstatus

					// Empfangene Zeichen von BYTE in String umwandeln
					char[]	chars	= new char[aryRet.Length];
					Decoder	dec		= Encoding.UTF8.GetDecoder();
					int		charLen	= dec.GetChars(aryRet, 0, aryRet.Length, chars, 0);
					string inData			= new String(chars);

					// überflüssige Leerzeichen abschneiden
					inData	= inData.Trim();
					receiveTelegramm(inData);
					Console.WriteLine(inData);

				}
				client.SetupRecieveCallback( this );
			}
			else
			{
				client.Sock.Shutdown(SocketShutdown.Both);
				client.Sock.Close();
				//return;
			}
		}

		public override void stop()
		{
			base.stop();
			//if(m_rec_thread != null)
			//{
				try
				{
					//this.listenSocket.Close();
					this.listenSocket.Shutdown(SocketShutdown.Both);
				}
				catch(Exception e)
				{
					Console.Error.WriteLine("Fehler in SocketCommunicationComponent1 --> stop"+e.Message);
				}
			try
			{
				this.clientSocket.Shutdown(SocketShutdown.Both);
				this.clientSocket.Close();
			}
			catch(Exception ex)
			{
				Console.Error.WriteLine("Fehler in SocketCommunicationComponent2 --> stop"+ex.Message);
			}
					//Console.WriteLine(m_running);
				//m_rec_thread.Abort();
				//m_rec_thread.Interrupt();
				//m_rec_thread.IsAlive = false;
				//m_rec_thread.Suspend();
				//Console.WriteLine(m_rec_thread.ThreadState);
				//Console.WriteLine(m_rec_thread.IsAlive);
			//}
			m_status = AbstractCommunicationComponent.DISCONNECTED;

		}
		/// <summary>
		/// Konstruktor der SocketCommunicationComponent class 
		/// </summary>
		/// <param name="sps">SPS Referenz</param>
		public SocketCommunicationComponent(SPS sps):base(sps)
		{
			// IPEndPoint mit allen IP-Adressen und dem festgelegten Port initialisieren
			endpoint = new IPEndPoint(IPAddress.Any, Convert.ToInt32(this.Parameter[LOCAL_PORT]) );
			start();			
		}

		/// <summary>
		/// Thread der den listenSocket verwendet und ein Telegramm mit vorrausgehenden 
		/// Zeitstempel enthält.
		/// </summary>
		public void receiveThread()
		{
			// anfragenden Client entgegennehmen	
			// Send operations will time-out if confirmation 
			// is not received within 1000 milliseconds.

				this.listenSocket.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.SendTimeout, 100);
				this.listenSocket.SetSocketOption (SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, 100);
				this.listenSocket.SetSocketOption (SocketOptionLevel.Socket ,SocketOptionName.NoDelay,1);
				this.listenSocket.BeginAccept(new AsyncCallback( OnConnectionRequest ), this.listenSocket );

				while(m_running)				//solange der Parameter der Super klasse true ist
				{
					Thread.Sleep(100);
				}
				m_status = AbstractCommunicationComponent.DISCONNECTED;	//setzt den Verbindungsstatus

			try{
				Console.WriteLine("Available : "+this.listenSocket.Available);
				this.listenSocket.Shutdown(SocketShutdown.Both);
			}
			catch(Exception a){
				Console.Error.WriteLine("Fehler im listen Thread1 --->"+a.Message);
			}
			try
			{
				this.listenSocket.Close();
				//this.listenSocket.Shutdown(SocketShutdown.Receive);
			}
			catch(Exception e)
			{
				Console.Error.WriteLine("Fehler im listen Thread --->"+e.Message );
			}
			GC.Collect();
			GC.WaitForPendingFinalizers();	
			//this.listenSocket.EndAccept();
		}
		/// <summary>
		/// Get the new data and send it out to all other connections. 
		/// Note: If not data was recieved the connection has probably 
		/// died.
		/// </summary>
		/// <param name="ar"></param>
		public void OnConnectionRequest( IAsyncResult ar )
		{
			Socket listenclient1 = (Socket)ar.AsyncState;
			Socket s = null;
			SocketClient client;
			if(this.m_running == true)
			{
				try
				{
					s = listenclient1.EndAccept(ar);
				}
				catch(Exception e)
				{
					Console.Error.WriteLine("Fehler in SocketCommunicationComponent --> ListenClient.EndAccept \n"+e.Message );
				}
				if(s == null)
				{
					Console.Error.WriteLine("Fehler in SocketCommunicationComponent --> Socket nicht initialisiert");
				}
				else
				{
					client = new SocketClient(s);
					client.SetupRecieveCallback(this);				
				}
				listenclient1.BeginAccept(new AsyncCallback( OnConnectionRequest ), listenclient1 );
			}
			else
			{
				try
				{
					Console.WriteLine("Available : "+this.listenSocket.Available);
					listenclient1.Shutdown(SocketShutdown.Both);
				}
				catch(Exception a)
				{
					Console.Error.WriteLine("Fehler im OnConnectionRequest --->"+a.Message);
				}
				try
				{
					listenclient1.Close();
					//this.listenSocket.Shutdown(SocketShutdown.Receive);
				}
				catch(Exception e)
				{
					Console.Error.WriteLine("Fehler im OnConnectionRequest --->"+e.Message );
				}
				//listenclient1.Close();
				//listenclient1.Shutdown(SocketShutdown.Both);
			}
		}
		/// <summary>
		/// This function has to be executed, when a new telegramm (string) arrives.
		/// A new Telegramm (class) will be created and will be send to the responible SPS-Class
		/// </summary>
		/// <param name="t">the received telegramm (string)</param>
		public override void  receiveTelegramm(string t) // Interface-methode
		{
			if (t=="")return;
			Telegramm teleg = m_sps.TelegrammBuilder.getSIMTelegramm(t.Substring(23,t.Length-23));

			if(teleg!=null)
			{
				//teleg.setProperty(Telegramm.TIMESTAMP,t.Substring(0,23));
				teleg.TimeStamp=t.Substring(0,23);
				FactorialComplete(teleg);

				m_sps.receiveTelegramm(teleg);
				//m_sps.SimulationKernel.TelegrammPool.add(teleg);

			}
			else
			{
				TelegrammDefinition unknownT = new TelegrammDefinition();
				unknownT.Type="unknown";
				teleg=new Telegramm(unknownT);
				teleg.TimeStamp=t.Substring(0,23);
				teleg.TelegrammText=t.Substring(23,t.Length-23);
				teleg.Sps=this.m_sps;
				FactorialComplete(teleg);
			}
		}

		public override string sendDirectTelegramm( string t )
		{
			string inData		= "";						// Client-Anfrage als String

			try
			{
				string teleg_str = t;

				if (teleg_str != "")
				{
					teleg_str=teleg_str.PadRight(100,'y'); // auf 100 Zeichen erweitern

					byte[] byData = System.Text.Encoding.ASCII.GetBytes(teleg_str + "\n");
					int i = clientSocket.Send(byData);
					int		inBytes		= 0;						// Zähler empfangene Bytes
					byte[] buffer = new byte[1024];

					// Empfangen der Client-Anfrage
					if((inBytes = clientSocket.Receive(buffer)) > 0)
					{
						// Daten wurden empfangen --> Auswerten der Empfangenen Anfrage
						if (buffer != null) 
						{
							// Empfangene Zeichen von BYTE in String umwandeln
							char[]	chars	= new char[inBytes];
							Decoder	dec		= Encoding.UTF8.GetDecoder();
							int		charLen	= dec.GetChars(buffer, 0, inBytes, chars, 0);
							inData			= new String(chars);

							// überflüssige Leerzeichen abschneiden
							inData	= inData.Trim();
							//teleg.setProperty(Telegramm.TIMESTAMP,inData.Substring(0,23));
							if(inData.Substring(23,inData.Length-23)!=teleg_str)//überprüfen ob empfangenes Telegramm
								//mit gesendetem telegramm übereinstimmt.
							{
								Console.Error.WriteLine("Fehler in SocketCommunicationComponent --> Zeitstempel für falsches Telegramm empfangen");
							}
							Console.WriteLine(inData);
						}
					}
				}
			}
			catch(Exception ex){
				Console.Error.WriteLine("Fehler in SocketCommunicationComponent -> SendDirectTelegramm \n"+ex.Message);
			}

			return inData;
		}

		/// <summary>
		/// Sends a Telegramm and adds a time stamp after the Telegramm is successfully sent.
		/// </summary>
		/// <param name="t">The Telegramm to send</param>
		public override void sendTelegramm( Telegramm t)
		{
			lock(m_outQueue)
			{
				m_outQueue.Enqueue(t);
			}
			m_send_thread = new Thread(new ThreadStart(this.sendThread));
			m_send_thread.Name="sendeThread gesendet";
			m_send_thread.Start();
		}

		/// <summary>
		/// Thread zum sender der telegrammdaten per Socket
		/// </summary>
		public void sendThread()
		{
			try
			{
				Telegramm teleg;
				string teleg_str;

				//loop over all entries!
				while(m_outQueue.Count > 0 && m_running)
				{
					teleg = null;
					teleg_str="";

					lock(m_outQueue)
					{
						if(m_outQueue.Count > 0)
						{
							teleg = (Telegramm) m_outQueue.Dequeue();
							teleg_str = m_sps.TelegrammBuilder.getSPSTelegramm(teleg);
						}
					}

					if (teleg!=null)
					{
						teleg_str=teleg_str.PadRight(100,'x');
						byte[] byData = System.Text.Encoding.ASCII.GetBytes(teleg_str + "\n");
						lock(clientSocket)
						{
							int i = clientSocket.Send(byData);
							int		inBytes		= 0;						// Zähler empfangene Bytes
							byte[] buffer = new byte[1024];
							string inData		= "";						// Client-Anfrage als String

							// Empfangen der Client-Anfrage
							if((inBytes = clientSocket.Receive(buffer)) > 0)
							{
								// Daten wurden empfangen --> Auswerten der Empfangenen Anfrage
								if (buffer != null) 
								{
									// Empfangene Zeichen von BYTE in String umwandeln
									char[]	chars	= new char[inBytes];
									Decoder	dec		= Encoding.UTF8.GetDecoder();
									int		charLen	= dec.GetChars(buffer, 0, inBytes, chars, 0);
									inData			= new String(chars);

									// überflüssige Leerzeichen abschneiden
									inData	= inData.Trim();
									teleg.setProperty(Telegramm.TIMESTAMP,inData.Substring(0,23));
									teleg.TimeStamp=inData.Substring(0,23);
									//m_sps.SimulationKernel.TelegrammPool.add(teleg);
									FactorialComplete(teleg);

									if(inData.Substring(23,inData.Length-23)!=teleg_str)//überprüfen ob empfangenes Telegramm
										//mit gesendetem telegramm übereinstimmt.
									{
										Console.Error.WriteLine("Fehler in SocketCommunicationComponent --> *********++++++++########Fehler########++++++++*********");
									}
									Console.WriteLine(inData);
								}
							}
						}
					}
				}
			}
			catch(Exception ex)
			{
				Console.WriteLine("Fehler in SocketCommunicationComponent --> "+ex.Message);
			}
		}
	}
}

using System;
using System.Net.Sockets;

namespace SSIM2
{
	/// <summary>
	/// Class holding information and buffers for the Client socket connection
	/// </summary>
	public class SocketClient
	{
		private Socket m_sock;						// Connection to the client
		private byte[] m_byBuff = new byte[1024];		// Receive data buffer
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="sock">client socket conneciton this object represents</param>
		public SocketClient( Socket sock )
		{
			m_sock = sock;
		}

		// Readonly access
		public Socket Sock
		{
			get{ return m_sock; }
		}

		/// <summary>
		/// Setup the callback for recieved data and loss of conneciton
		/// </summary>
		/// <param name="app"></param>
		public void SetupRecieveCallback( SocketCommunicationComponent scc )
		{
			try
			{
				AsyncCallback recieveData = new AsyncCallback(scc.OnRecievedData);
				m_sock.BeginReceive( m_byBuff, 0, m_byBuff.Length, SocketFlags.None, recieveData, this );
			}
			catch( Exception ex )
			{
				Console.WriteLine( "Recieve callback setup failed! {0}", ex.Message );
			}
		}

		/// <summary>
		/// Data has been recieved so we shall put it in an array and
		/// return it.
		/// </summary>
		/// <param name="ar"></param>
		/// <returns>Array of bytes containing the received data</returns>
		public byte [] GetRecievedData( IAsyncResult ar )
		{
			int nBytesRec = 0;
			try
			{
				nBytesRec = m_sock.EndReceive( ar );
			}
			catch{}
			byte [] byReturn = new byte[nBytesRec];
			Array.Copy( m_byBuff, byReturn, nBytesRec );

			// Check for any remaining data and display it
			// This will improve performance for large packets 
			// but adds nothing to readability and is not essential
			int nToBeRead = m_sock.Available;
			if( nToBeRead > 0 )
			{
				byte [] byData = new byte[nToBeRead];
				m_sock.Receive( byData );
				// Append byData to byReturn here
			}

			return byReturn;
		}
	}
}

Vielleicht hat ja jemand schon mal das gleiche Problem gehabt und kann mir helfen

mfg finalmove