Sockets: send strings from Java to C #?

Well, I already did this in one of my projects, and so:
disclaimer: some of the code (actually a little) is based on the nakov chav server.
also note that I decode and encode all messages sent and received in UTF-8.

Java Code:

Class: Server

import java.net.*;
import java.io.*;
import javax.swing.*; 

public class Server
{

    private static void createAndShowGUI() {
        //Create and set up the window
    }


public static final int LISTENING_PORT = 2002; 

public static void main(String[] args)
{
    // Open server socket for listening
    ServerSocket serverSocket = null;
    try 
    {
       serverSocket = new ServerSocket(LISTENING_PORT);
       javax.swing.SwingUtilities.invokeLater(new Runnable() {
           public void run() {
               createAndShowGUI();
           }
       });
       //System.out.println("Server started on port " + LISTENING_PORT);
    }
    catch (IOException se) 
    {
       System.err.println("Can not start listening on port " + LISTENING_PORT);
       se.printStackTrace();
       System.exit(-1);
    }

    // Start ServerDispatcher thread
    ServerDispatcher serverDispatcher = new ServerDispatcher();


    // Accept and handle client connections
    while (true) 
    {   
       try  
       {
           Socket socket = serverSocket.accept();
           ClientInfo clientInfo = new ClientInfo();
           clientInfo.mSocket = socket;
           ClientListener clientListener =
               new ClientListener(clientInfo, serverDispatcher);
           ClientSender clientSender =
               new ClientSender(clientInfo, serverDispatcher);
           clientInfo.mClientListener = clientListener;
           clientInfo.mClientSender = clientSender;
           clientListener.start();
           clientSender.start();
           serverDispatcher.addClient(clientInfo);
       }
       catch (IOException ioe) 
       {
           ioe.printStackTrace();
       }
    }
}

}

Class Message Manager:

    import java.io.UnsupportedEncodingException;
        import java.net.*;
    import java.util.*;

    public class ServerDispatcher 
        {
        private Vector mMessageQueue = new Vector();
        private Vector<ClientInfo> mClients = new Vector<ClientInfo>();


    public synchronized void addClient(ClientInfo aClientInfo) {
        mClients.add(aClientInfo);
    }

    public synchronized void deleteClient(ClientInfo aClientInfo) {
        int clientIndex = mClients.indexOf(aClientInfo);
        if (clientIndex != -1)
            mClients.removeElementAt(clientIndex);
    }


    private synchronized void sendMessageToAllClients(String aMessage)
    {
        for (int i = 0; i < mClients.size(); i++) {
            ClientInfo infy = (ClientInfo) mClients.get(i);
            infy.mClientSender.sendMessage(aMessage);
                              } 
    }   




    public void sendMessage(ClientInfo aClientInfo, String aMessage) {
        aClientInfo.mClientSender.sendMessage(aMessage);

    }


}

Class: ClientInfo

/**
 *
 * ClientInfo class contains information about a client, connected to the server.
 */

import java.awt.List;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Vector;

public class ClientInfo
{

    public int userID=-1;
    public Socket mSocket = null;
    public ClientListener mClientListener = null;
    public ClientSender mClientSender = null;
}

ClientListner Class:

/**
 * ClientListener class is purposed to listen for client messages and
 * to forward them to ServerDispatcher.
 */

import java.io.*;
import java.net.*;

public class ClientListener extends Thread {
    private ServerDispatcher mServerDispatcher;
    private ClientInfo mClientInfo;
    private BufferedReader mIn;
    private String message;
    private String decoded = null;

    public ClientListener(ClientInfo aClientInfo,
            ServerDispatcher aServerDispatcher) throws IOException {
        mClientInfo = aClientInfo;
        mServerDispatcher = aServerDispatcher;
        Socket socket = aClientInfo.mSocket;
        mIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
    }

    /**
     * Until interrupted, reads messages from the client socket, forwards them
     * to the server dispatcher and notifies the server dispatcher.
     */
    public void run() {
        message = "";
        while (!isInterrupted()) {
            try {
                message = mIn.readLine();
                if (message == null)
                    break;
                try {
                    decoded = URLDecoder.decode(message, "UTF-8");
                } catch (UnsupportedEncodingException e)
                    e.printStackTrace();
                }
                mServerDispatcher.sendMessage(mClientInfo, decoded);

            } 

            catch (IOException e) {
                break;
            }

        }

        // Communication is broken. Interrupt both listener and sender threads
        mClientInfo.mClientSender.interrupt();
        mServerDispatcher.deleteClient(mClientInfo);
    }

}

Class: ClientSender

/**
 * Sends messages to the client. Messages are stored in a message queue. When
 * the queue is empty, ClientSender falls in sleep until a new message is
 * arrived in the queue. When the queue is not empty, ClientSender sends the
 * messages from the queue to the client socket.
 */

import java.io.*;
import java.net.*;
import java.util.*;

public class ClientSender extends Thread
{
    private Vector mMessageQueue = new Vector();

    private ServerDispatcher mServerDispatcher;
    private ClientInfo mClientInfo;
    private PrintWriter mOut;

    public ClientSender(ClientInfo aClientInfo, ServerDispatcher aServerDispatcher)
    throws IOException
    {
        mClientInfo = aClientInfo;
        mServerDispatcher = aServerDispatcher;
        Socket socket = aClientInfo.mSocket;
        mOut = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
    }

    /**
     * Adds given message to the message queue and notifies this thread
     * (actually getNextMessageFromQueue method) that a message is arrived.
     * sendMessage is called by other threads (ServeDispatcher).
     */
    public synchronized void sendMessage(String aMessage)
    {
        mMessageQueue.add(aMessage);
        notify();
    }

    /**
     * @return and deletes the next message from the message queue. If the queue
     * is empty, falls in sleep until notified for message arrival by sendMessage
     * method.
     */
    private synchronized String getNextMessageFromQueue() throws InterruptedException
    {
        while (mMessageQueue.size()==0)
           wait();
        String message = (String) mMessageQueue.get(0);
        mMessageQueue.removeElementAt(0);
        return message;
    }

    /**
     * Sends given message to the client socket.
     */
    private void sendMessageToClient(String aMessage)
    {
         String encoded;
        try {
            encoded = URLEncoder.encode(aMessage,"UTF-8");
            mOut.println(encoded);
            mOut.flush();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

    }

    /**
     * Until interrupted, reads messages from the message queue
     * and sends them to the client socket.
     */
    public void run()
    {
        try {
           while (!isInterrupted()) {
               String message = getNextMessageFromQueue();


               sendMessageToClient(message);
           }
        } catch (Exception e) {
           // Commuication problem
       break;
        }

        // Communication is broken. Interrupt both listener and sender threads
        mClientInfo.mClientListener.interrupt();
        mServerDispatcher.deleteClient(mClientInfo);
    }

}

, java, #

# :

Varibales:

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

: Intelize:

private void InitializeConnection()
{
    // Parse the IP address

    string ipAdress = "XXX.XXX.XXX.XXX";
    ipAddr = IPAddress.Parse(ipAdress);


    // Start a new TCP connections to the chat server
    tcpServer = new TcpClient();
    try
    {
        tcpServer.Connect(ipAddr, 2002);
        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)
        {
            MessageBox.Show(e2.ToString());
        }
    }



}

: ReciveMessages

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);



            }
        }

: proceesMessage:

private void processMessage(String p)
        {
        // do something with the message
        }

sendMessage:

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

            }

        }

thats it thats , java- #. - , .