.net remoting problem with chat server

I have a problem with my chat server implementation and I couldn't figure out why it doesn't work as intended.

The client could send messages to the server, but the server only sends the messages to itself instead of the client.

E.g. the client connects to the server, then types "hello" into the chat. The server successfully gets the message but then posts the message to its own console instead of sending it to the connected clients.

Well... maybe I have missed something as I'm very new to .Net remoting. Maybe someone could help me figure out what the problem is. Any help is appreciated!

The code:

I have a small interface for the chat implementation on the server

 public class ChatService : 开发者_运维百科MarshalByRefObject, IService
 {
private Dictionary<string, IClient> m_ConnectedClients = new Dictionary<string, IClient>();
private static ChatService _Chat;

private ChatService()
{
    Console.WriteLine("chat service created");
    _Chat = this;
}

public bool Login(IClient user)
{
    Console.WriteLine("logging in: " + user.GetIp());
    if (!m_ConnectedClients.ContainsKey(user.GetIp()))
    {
            m_ConnectedClients.Add(user.GetIp(), user);
        PostMessage(user.GetIp(), user.GetUserName() + " has entered chat");
        return true;
    }

    return false;
}

public bool Logoff(string ip)
{
    Console.WriteLine("logging off: " + ip);
    IClient user;

    if (m_ConnectedClients.TryGetValue(ip, out user))
    {
        PostMessage(ip, user + " has left chat");
        m_ConnectedClients.Remove(ip);
        return true;
    }

    return false;
}

   public bool PostMessage(string ip, string text)
   {
            Console.WriteLine("posting message: " + text + " to: " + m_ConnectedClients.Values.Count);
    foreach (var chatter in m_ConnectedClients.Values)
    {
        Console.WriteLine(chatter.GetUserName() + " : " + chatter.GetIp());
        chatter.SendText(text);
    }

    return true;
}

}

My Server implements the chatservice as singleton:

RemotingConfiguration.RegisterWellKnownServiceType(typeof(ChatService), "chatservice",  WellKnownObjectMode.Singleton);

My client is also simply straight forward:

[Serializable]
public class Chat_Client : IClient
{
    private string m_IpAdresse;
    private string m_UserName = "Jonny";
    private string m_Input;

    public Chat_Client(string ip, string username)
    {
        m_IpAdresse = ip;
        m_UserName = username;
    }

    public bool HandleInput(string input)
    {
        if (input.Equals("exit"))
        {
            Client.m_ChatService.Logoff(m_IpAdresse);
            return false;
        }

        m_Input = input;
        Thread sendThread = new Thread(new ThreadStart(SendPostMessage));
        sendThread.Start();

        //Console.WriteLine("post message");
        return true;
    }

    private void SendPostMessage()
    {
        Client.m_ChatService.PostMessage(m_IpAdresse, m_Input);

        Thread thisThread = Thread.CurrentThread;
        thisThread.Interrupt();
        thisThread.Abort();
    }


    public void SendText(string text)
    {
        Console.WriteLine("send text got: " + text);
        Console.WriteLine(text);
    }

The main client connects to the server via:

public void Connect()
{
        try
        {
            TcpChannel channel = new TcpChannel(0);
            ChannelServices.RegisterChannel(channel, false);
            m_ChatService = (IService)Activator.GetObject(typeof(IService), "tcp://" + hostname + ":9898/Host/chatservice");

            System.Net.IPHostEntry hostInfo = Dns.GetHostEntry(Dns.GetHostName());
            m_IpAdresse = hostInfo.AddressList[0].ToString();

            Chat_Client client = new Chat_Client(m_IpAdresse, m_UserName);

            Console.WriteLine("Response from Server: " + m_ChatService.Login(client));

            string input = "";

            while (m_Running)
            {
                input = Console.ReadLine();
                m_Running = client.HandleInput(input);
            }
        }
}

---

@John: No, I wasn't aware of that. Thanks for the info, I'll look into it.

@Felipe: hostname is the dns name of the server I want to connect to.

I found a workaround to make this work. I added an additional TcpListener to the client to which the server connects when the client logs in. Over this second channel I transmit the chat messages back.

However I couldn't understand why the old solution does not work :<

Thanks for the hints guys.

---

The best thing to do with .NET remoting is to abandon it for WCF. If you read all the best practices for scalability, the way you end up using it is extremely compatible with the Web Services model, and web services is far easier to work with.

Remoting is technically fascinating and forms the basis of reflection, but falls apart once slow, unreliable connections are involved - and all connections are slow and unreliable compared to in-process messaging.