' The following function creates a TcpServer that connects to  
' the specified port (13000).
' Refer to the related client in the TcpClient class. 

Public Shared Sub Main()
   
   Try
      ' Set the TcpListener on port 13000.
      Dim port As Int32 = 13000
      Dim server As New TcpListener(port)
      
      ' Start listening for client requests.
      server.Start()
      
      ' Buffer for reading data
      Dim bytes(1024) As [Byte]
      Dim data As [String] = Nothing
      
      ' Enter the listening loop.
      While True
         Console.Write("Waiting for a connection... ")
         
         ' Perform a blocking call to accept requests.
         ' You could also user server.AcceptSocket() here.
         Dim client As TcpClient = server.AcceptTcpClient()
         Console.WriteLine("Connected!")
         
         data = Nothing
         
         ' Get a stream object for reading and writing
         Dim stream As NetworkStream = client.GetStream()
         
         Dim i As Int32
         
         ' Loop to receive all the data sent by the client.
         i = stream.Read(bytes, 0, bytes.Length)
         While (i <> 0) 
            ' Translate data bytes to a ASCII string.
            data = System.Text.Encoding.ASCII.GetString(bytes, 0, i)
            Console.WriteLine([String].Format("Received: {0}", data))
            
            ' Process the data sent by the client.
            data = data.ToUpper()
            
            Dim msg As [Byte]() = System.Text.Encoding.ASCII.GetBytes(data)
            
            ' Send back a response.
            stream.Write(msg, 0, msg.Length)
            Console.WriteLine([String].Format("Sent: {0}", data))
           
            i = stream.Read(bytes, 0, bytes.Length)

         End While
         
         ' Shutdown and end connection
         client.Close()
      End While
   Catch e As SocketException
      Console.WriteLine("SocketException: {0}", e)
   End Try
   
   Console.WriteLine(ControlChars.Cr + "Hit enter to continue...")
   Console.Read()
End Sub 'Main

     // Create a socket and connect with a remote host.
IPHostEntry myIpHostEntry = Dns.Resolve("www.contoso.com");
IPEndPoint myIpEndPoint = new IPEndPoint(myIpHostEntry.AddressList[0], 1001);

     Socket mySocket = new Socket(myIpEndPoint.Address.AddressFamily,
                                SocketType.Stream,
                                       ProtocolType.Tcp);
     try{
          mySocket.Connect(myIpEndPoint);
     
          
          // Create the NetworkStream for communicating with the remote host.
          NetworkStream myNetworkStream;
          
          if (networkStreamOwnsSocket){
               myNetworkStream = new NetworkStream(mySocket, true);          
          }
          else{
               myNetworkStream = new NetworkStream(mySocket);     
          }

         
          // Check to see if this NetworkStream is writable.
          if (myNetworkStream.CanWrite){
             
               byte[] myWriteBuffer = Encoding.ASCII.GetBytes("Are you receiving this message?");
               myNetworkStream.Write(myWriteBuffer, 0, myWriteBuffer.Length);
          }
          else{
               Console.WriteLine("Sorry.  You cannot write to this NetworkStream.");  
          }


         
          // Check to see if this NetworkStream is readable.
          if(myNetworkStream.CanRead){
              byte[] myReadBuffer = new byte[1024];
              StringBuilder myCompleteMessage = new StringBuilder();
              int numberOfBytesRead = 0;

              // Incoming message may be larger than the buffer size.
              do{
                   numberOfBytesRead = myNetworkStream.Read(myReadBuffer, 0, myReadBuffer.Length);

                   myCompleteMessage.AppendFormat("{0}", Encoding.ASCII.GetString(myReadBuffer, 0, numberOfBytesRead));
                                   
              }
              while(myNetworkStream.DataAvailable);

              // Print out the received message to the console.
              Console.WriteLine("You received the following message : " +
                                           myCompleteMessage);
          }
          else{
               Console.WriteLine("Sorry.  You cannot read from this NetworkStream.");
          }



          // Close the NetworkStream
          myNetworkStream.Close();

     }
     catch (Exception exception){
          Console.WriteLine("Exception Thrown: " + exception.ToString());
     }
     

  }

/**
 * The following function creates a TcpServer that connects to  
 * the specified port (13000).Any TcpClient that wants to use this server
 * has to explicitly connect to an address obtained by the combination of
 * the sever on which this TCpServer is runnig and the port 13000. 
 * This TcpServer simply echoes back the message sent by the TcpClient, after
 * translating it into uppercase. 
 * Refer to the related client in the TcpClient class. 
 **/
int main()
{
   try
   {
      
      // Set the TcpListener on port 13000.
      Int32 port = 13000;
      TcpListener^ server = gcnew TcpListener( port );
      
      // Start listening for client requests.
      server->Start();
      
      // Buffer for reading data
      array<Byte>^bytes = gcnew array<Byte>(256);
      String^ data = nullptr;
      
      // Enter the listening loop.
      while ( true )
      {
         Console::Write( "Waiting for a connection... " );
         
         // Perform a blocking call to accept requests.
         // You could also user server.AcceptSocket() here.
         TcpClient^ client = server->AcceptTcpClient();
         Console::WriteLine( "Connected!" );
         data = nullptr;
         
         // Get a stream object for reading and writing
         NetworkStream^ stream = client->GetStream();
         Int32 i;
         
         // Loop to receive all the data sent by the client.
         while ( (i = stream->Read( bytes, 0, bytes->Length )) != 0 )
         {
            
            // Translate data bytes to a ASCII string.
            data = System::Text::Encoding::ASCII->GetString( bytes, 0, i );
            Console::WriteLine( String::Format( "Received: {0}", data ) );
            
            // Process the data sent by the client.
            data = data->ToUpper();
            array<Byte>^msg = System::Text::Encoding::ASCII->GetBytes( data );
            
            // Send back a response.
            stream->Write( msg, 0, msg->Length );
            Console::WriteLine( String::Format( "Sent: {0}", data ) );
         }
         
         // Shutdown and end connection
         client->Close();
      }
   }
   catch ( SocketException^ e ) 
   {
      Console::WriteLine( "SocketException: {0}", e );
   }

   Console::WriteLine( "\nHit enter to continue..." );
   Console::Read();
}

/**
* The following function creates a TcpServer that connects to  
* the specified port (13000).Any TcpClient that wants to use this server
* has to explicitly connect to an address obtained by the combination of
* the sever on which this TCpServer is runnig and the port 13000. 
* This TcpServer simply echoes back the message sent by the TcpClient, 
* after translating it into uppercase. 
* Refer to the related client in the TcpClient class. 
*/
public static void main(String[] args)
{
    try {
        // Set the TcpListener on port 13000.
        int port = 13000;
        TcpListener server = new TcpListener(port);

        // Start listening for client requests.
        server.Start();

        // Buffer for reading data
        ubyte bytes[] = new ubyte[256];
        String data = null;

        // Enter the listening loop.
        while (true) {
            Console.Write("Waiting for a connection... ");

            // Perform a blocking call to accept requests.
            // You could also user server.AcceptSocket() here.
            TcpClient client = server.AcceptTcpClient();
            Console.WriteLine("Connected!");
            data = null;

            // Get a stream object for reading and writing
            NetworkStream stream = client.GetStream();
            int i;

            // Loop to receive all the data sent by the client.
            while (((i = stream.Read(bytes, 0, bytes.length)) != 0)) {
                // Translate data bytes to a ASCII string.
                data = System.Text.Encoding.get_ASCII().GetString(
                    bytes, 0, i);
                Console.WriteLine(String.Format("Received: {0}", data));

                // Process the data sent by the client.
                data = data.ToUpper();
                ubyte msg[] = System.Text.Encoding.get_ASCII().GetBytes(
                    data);

                // Send back a response.
                stream.Write(msg, 0, msg.length);
                Console.WriteLine(String.Format("Sent: {0}", data));
            }

            // Shutdown and end connection
            client.Close();
        }
    }
    catch (SocketException e) {
        Console.WriteLine("SocketException: {0}", e);
    }
    Console.WriteLine("\nHit enter to continue...");
    Console.Read();
} //main