Managed C++/CLI

array<Byte>^ SendMessage = Encoding::ASCII->GetBytes("DATA TO SEND");
Sock->Send(SendMessage, SendMessage->Length, SocketFlags::None);

public: void SendMessage(String^ UserMessage)
{
	/* Check if there is a connection */
	if (Sock == null || Sock->Connected == false)
	{
		text_output->Text += "\nERROR: First connect before sending data.\n";
		return;
	}

	try
	{
		/* Encode the user message and send it */
		array<Byte>^ SendMessage = Encoding::ASCII->GetBytes("DATA TO SEND");

		Sock->BeginSend(SendMessage, 0, SendMessage->Length, SocketFlags::None, gcnew AsyncCallback(this, namesp_class::SendData), Sock);
	}

	catch (...)
	{
			text_output->Text += "ERROR: Could not send message.\n";
	}
}

public: void SendData (IAsyncResult^ ar)
		{
				/* Exstract the receiving socket */
				Socket^ s = (Socket^)ar->AsyncState;

				int send = s->EndSend(ar);
		}

/* Global Variables */
Socket^ Sock;
array<Byte>^ InputBuffer;

public: void Telnet_Load()
{
	Delegate_AddMessage = gcnew AddMessage (this, namesp_class::OutputMessage);
	this->output_textbox->TextChanged += gcnew System::EventHandler(this, namesp_class::output_textbox_TextChanged);
}


public: void Read(String^ Host, int Port)
{
	/* Set the sandglass as cursor */
	Cursor = Cursors::WaitCursor;

	try
	{
		/* When the socket is open */
		if (Sock != null && Sock->Connected == true)
		{
			/* Shutdown the socket for send and receive, wait and close the socket. */
			Sock->Shutdown(SocketShutdown::Both);
			sleep(10);
			Sock->Close();
		}

		/* open a new TCP socket */
		Sock = gcnew Socket(AddressFamily::InterNetwork, SocketType::Stream, ProtocolType::Tcp);

		/* Set an IP point with the user given parameters */
		IPEndPoint^ ip = gcnew IPEndPoint (IPAddress::Parse(Host), Port);

		/* Socket blocking is false for asynchrone data connection. */
		Sock->Blocking = false;

		/* Declare a new asynchone callback */
		AsyncCallback^ onconnect = gcnew AsyncCallback(this, namesp_class::OnConnect);

		/* begin a asynchrone connection to the given IP, when connected the next function will be called. */
		Sock->BeginConnect(ip, onconnect, Sock);

	}
	catch (...)
	{
		Invoke (Delegate_AddMessage, "ERROR: Could not connect to remote machine.\n");
	}

	/* Put the cursor back to arrow */
	Cursor = Cursors::Arrow;
}

public: void OnConnect(IAsyncResult^ ar)
{
	/* Get the state of the socket */
	Socket^ s = (Socket^)ar->AsyncState; 

	try
	{
		/* When in the last function the socket has connected succesfully */
		if (s->Connected == true)
		{
			/* Let the user know he is connected */
			Invoke (Delegate_AddMessage, "Connected.\n");

			/* Pass the socket to the next function */
			SetupReceiveCallback(s);
		}
		else
		{
			Invoke (Delegate_AddMessage, "ERROR: Could not connect to remote machine.\n");
		}
	}
	catch (...)
	{
		Invoke (Delegate_AddMessage, "ERROR: Unknow error during connect.\n");
	}
}

public: void SetupReceiveCallback(Socket^ s)
{
	/* Declare the inputbuffer */
	InputBuffer = gcnew array<Byte>(InputBufferSize);
	try
	{
		/* Declare a new asynchone callback  */
		AsyncCallback^ Receive = gcnew AsyncCallback(this, namesp_class::OnReceivedData);

		/* Store the received data in the inputbuffer, When this operation is completed go the the onreceived function */
		s->BeginReceive(InputBuffer, 0, InputBuffer->Length, SocketFlags::None, Receive, s);
	}
	catch(...)
	{
		Invoke (Delegate_AddMessage, "ERROR: Setup receive callback failed.\n");
	}
}

public: void OnReceivedData(IAsyncResult^ ar)
{
	/* Exstract the receiving socket */
	Socket^ s = (Socket^)ar->AsyncState;

	try
	{
		/* Get the number of received data */
		int bytes = s->EndReceive(ar);

		/* When there is still data availible (will be 0 when the connection is closed) */
		if (bytes > 0)
		{
			/* Encode the received message and put it into a string */
			String^ receivedmessage = Encoding::ASCII->GetString(InputBuffer, 0, bytes);
			receivedmessage = "> " + receivedmessage + "\n";

			/* Put the message as objectarray in the delegate. */
			array<Object^>^ stringarray = {receivedmessage};
			Invoke (Delegate_AddMessage, stringarray);

			/* Go back to the receivecallback and receive data again. */
			SetupReceiveCallback(s);
		}
	}
	catch (...)
	{
		Invoke (Delegate_AddMessage, "ERROR: error during data receive.\n");
	}
}

public: void CloseConnection()
{
	/* When there is a connection */
	if (Sock != null && Sock->Connected == true)
	{
		/* Shutdown both the receive and send buffers and close the socket. */
		Sock->Shutdown(SocketShutdown::Both);
		sleep(10);
		Sock->Close();
	}
}

/* Put the message to the right control */
public: void OutputMessage (String^ Message)
{
	/* Get the first character of the string */
	String^ FirstChar = Message[0].ToString();

	/* When it is a received message */
	if (FirstChar == ">")
	{
		output_textbox->SelectionColor = Received_Message_Color;
		output_textbox->SelectedText += Message;
	}
	/* Else on program messages */
	else
	{
		output_textbox->SelectionColor = Program_Message_Color;
		output_textbox->SelectedText += Message;
	}
}

/* Scroll the textbox with the text */
public: void output_textbox_TextChanged(System::Object^  sender, System::EventArgs^  e) 
{
	output_textbox->Focus();
	output_textbox->SelectionLength = 0;
	output_textbox->SelectionStart = output_textbox->TextLength;
	output_textbox->ScrollToCaret();
}