C#

Mark Salsbery wrote:

Um...sockets is C technically

class Program
    {
        private StreamWriter swSender;
        private StreamReader srReceiver;
        private TcpClient tcpServer;
        private Thread thrMessaging;
        private IPAddress ipAddr;
        private bool Connected;

        private string receivedData;

        static void Main(string[] args)
        {
            System.Diagnostics.Process.Start(Path.GetFullPath("RunJar.bat"));
            Console.WriteLine("C# Sockets Program has started.");

            try
            {
                Program prog = new Program();
                prog.InitializeConnection();
            }
            catch (Exception e) { Console.WriteLine(e); }

            Console.ReadLine();
        }


        private void InitializeConnection()
        {
            // Parse the IP address
            string ipAdress = "127.0.0.1";
            ipAddr = IPAddress.Parse(ipAdress);

            // Start a new TCP connections to the chat server
            tcpServer = new TcpClient();
            try
            {
                tcpServer.Connect(ipAddr, 1800);
                swSender = new StreamWriter(tcpServer.GetStream());

                // Start the thread for receiving messages and further communication
                thrMessaging = new Thread(new ThreadStart(ReceiveMessages));
                thrMessaging.Start();
                Connected = true;
            }
            catch (Exception e2)
            {
                Console.WriteLine(e2.ToString());
            }
        }

        private void ReceiveMessages()
        {
            // Receive the response from the server
            srReceiver = new StreamReader(tcpServer.GetStream());
            while (Connected)
            {
                String con = srReceiver.ReadLine();
                string StringMessage = HttpUtility.UrlDecode(con, System.Text.Encoding.UTF8);

                processMessage(StringMessage);
            }
        }

        private void processMessage(String p)
        {
            // do something with the message
            Console.WriteLine(p);
        }

        private void SendMessage(String p)
        {
            if (p != "")
            {
                p = HttpUtility.UrlEncode(p, System.Text.Encoding.UTF8);
                swSender.WriteLine(p);
                swSender.Flush();
            }
        }

    }

public class JavaSocket {

 public void runJavaSocket() {
  
  System.out.println("Java Sockets Program has started.");
  
  try {
   Socket s = new Socket("127.0.0.1", 1800);
   s.connect(new InetSocketAddress("127.0.0.1", 1800), 10000);
   while (!s.isConnected()) {
    s.connect(new InetSocketAddress("127.0.0.1", 1800), 10000);
   }
   System.out.println("java Socket Connected.");
      OutputStream out = s.getOutputStream();
      out.write("helloFromjavaCode".getBytes());
      out.flush();
      out.close();
   
   
   /*
   ServerSocket ss = new ServerSocket(1800);
   Socket s = ss.accept();
   System.out.println("Client Accepted");
   BufferedReader br = new BufferedReader(new InputStreamReader(
     s.getInputStream()));
   System.out.println(br.readLine());
   PrintWriter wr = new PrintWriter(new OutputStreamWriter(
     s.getOutputStream()), true);
   wr.println("Welcome to Socket Programming");
   */
  } catch (Exception e) {
   System.out.println(e);
  }
  
  try {
   @SuppressWarnings("unused")
   int a = System.in.read();
  }
  catch (Exception e) {}
 }

}

         public void runJavaSocket() {
		System.out.println("Java Sockets Program has started."); int i=0;

		try {
			DatagramSocket socket = new DatagramSocket();
			System.out.println("Sending the udp socket...");
	        // Send the Message "HI"
	        socket.send(toDatagram("HI",InetAddress.getByName("127.0.0.1"),3800));
        	while (true)
        	{
	        	System.out.println("Sending hi " + i);
				Thread.currentThread();
				Thread.sleep(1000);
				socket.send(toDatagram("HI " + String.valueOf(i),InetAddress.getByName("127.0.0.1"),3800));
				i++;
        	}
		} catch (Exception e) {
			e.printStackTrace();
		}
}
	public DatagramPacket toDatagram(
			  String s, InetAddress destIA, int destPort) {
		// Deprecated in Java 1.1, but it works:
		byte[] buf = new byte[s.length() + 1];
		s.getBytes(0, s.length(), buf, 0);
		// The correct Java 1.1 approach, but it's
		// Broken (it truncates the String):
		// byte[] buf = s.getBytes();
		return new DatagramPacket(buf, buf.length, 
		destIA, destPort);
		}

string returnData;
byte[] receiveBytes;
//ConsoleKeyInfo cki = new ConsoleKeyInfo();

using (UdpClient udpClient = new UdpClient(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3800)))
{
    IPEndPoint remoteIpEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 3800);
    while (true)
    {
        receiveBytes = udpClient.Receive(ref remoteIpEndPoint);
        returnData = Encoding.ASCII.GetString(receiveBytes);
        Console.WriteLine(returnData);
    }
}

5. ...
6. Profit!

S<T>::f(U) // Out of line.

\b[a-zA-Z][a-zA-Z]*\b\s*\b[a-zA-Z][a-zA-Z]*\b