I have been following a tutorial which implements a tcp server and client chat program. I've been looking for resources as to how exactly go about it for about a week and am finally asking.
I have two hashtables on the server which store the IP and the username of each client connected to the server, yet I don't know how to send the hash tables over to the client to fill in a list view. I saw a few options here ;
- Change it to an array and send it over with get byte and use xml serializer. yet for recieving I don't quiete know what to do.
- change the hash tables to sql tables instead and send that. Still not sure how to send and receive them.
- Or forgo listing any users in a ListView box and try to build a functionality which passes a /w or /tell command which would required the server to interpret a "/" command which I'm not to familiar with nor can find any instructions on.
any suggestiong would be helpful over than specifying I should drop the project and switch over to WCF /WPF , which would possibly be easier but its very late in the game for me to do so =)
-- I think there is an array but still don't know how to pass the value to each client
"TcpClient[] tcpClients = new TcpClient[ChatServer.htUsers.Count];" Heres the code for it
using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
using System.Collections;
namespace ChatServer
{
public class StatusChangedEventArgs : EventArgs
{
private string EventMsg;
public string EventMessage
{
get
{
return EventMsg;
}
set
{
EventMsg = value;
}
}
public StatusChangedEventArgs(string strEventMsg)
{
EventMsg = strEventMsg;
}
}
public delegate void StatusChangedEventHandler(object sender, StatusChangedEventArgs e);
class ChatServer
{
public static Hashtable htUsers = new Hashtable(100);
public static Hashtable htConnections = new Hashtable(100);
private IPAddress ipAddress;
private TcpClient tcpClient;
public static event StatusChangedEventHandler StatusChanged;
private static StatusChangedEventArgs e;
public ChatServer(IPAddress address)
{
ipAddress = address;
}
private Thread thrListener;
private TcpListener tlsClient;
bool ServRunning = false;
// Add the user to the hash tables
public static void AddUser(TcpClient tcpUser, string strUsername)
{
// add the username and associated connection to both hash tables
ChatServer.htUsers.Add(strUsername, tcpUser);
ChatServer.htConnections.Add(tcpUser, strUsername);
SendAdminMessage(htConnections[tcpUser] + " has joined us");
}
// Remove the user from the hash tables
public static void RemoveUser(TcpClient tcpUser)
{
// If the user is there
if (htConnections[tcpUser] != null)
{
SendAdminMessage(htConnections[tcpUser] + " has left us");
// Remove the user from the hash table
ChatServer.htUsers.Remove(ChatServer.htConnections[tcpUser]);
ChatServer.htConnections.Remove(tcpUser);
}
}
event
public static void OnStatusChanged(StatusChangedEventArgs e)
{
StatusChangedEventHandler statusHandler = StatusChanged;
if (statusHandler != null)
{
// Invoke the delegate
statusHandler(null, e);
}
}
public static void SendAdminMessage(string Message)
{
StreamWriter swSenderSender;
e = new StatusChangedEventArgs("Administrator: " + Message);
OnStatusChanged(e);
TcpClient[] tcpClients = new TcpClient[ChatServer.htUsers.Count];
// Copy the TcpClient objects into the array
ChatServer.htUsers.Values.CopyTo(tcpClients, 0);
// Loop through the list of TCP clients
for (int i = 0; i < tcpClients.Length; i++)
{
// Try sending a message to each
try
{
// If the message is blank or the connection is null, break out
if (Message.Trim() == "" || tcpClients[i] == null)
{
continue;
}
// Send the message to the current user in the loop
swSenderSender = new StreamWriter(tcpClients[i].GetStream());
swSenderSender.WriteLine("Administrator: " + Message);
swSenderSender.Flush();
swSenderSender = null;
}
catch // If there was a problem, the user is not there anymore, remove him
{
RemoveUser(tcpClients[i]);
}
}
}
// Send messages from one user to all the others
public static void SendMessage(string From, string Message)
{
StreamWriter swSenderSender;
// First of all, show in our application who says what
e = new StatusChangedEventArgs(From + " says: " + Message);
OnStatusChanged(e);
// Create an array of TCP clients, the size of the number of users we have
TcpClient[] tcpClients = new TcpClient[ChatServer.htUsers.Count];
// Copy the TcpClient objects into the array
ChatServer.htUsers.Values.CopyTo(tcpClients, 0);
// Loop through the list of TCP clients
for (int i = 0; i < tcpClients.Length; i++)
{
// Try sending a message to each
try
{
// If the message is blank or the connection is null, break out
if (Message.Trim() == "" || tcpClients[i] == null)
{
continue;
}
// Send the message to the current user in the loop
swSenderSender = new StreamWriter(tcpClients[i].GetStream());
swSenderSender.WriteLine(From + " says: " + Message);
swSenderSender.Flush();
swSenderSender = null;
}
catch // If there was a problem, the user is not there anymore, remove him
{
RemoveUser(tcpClients[i]);
}
}
}
public void StartListening()
{
// Get the IP of the first network device, however this can prove unreliable on certain configurations
IPAddress ipaLocal = ipAddress;
// Create the TCP listener object using the IP of the server and the specified port
tlsClient = new TcpListener(1986);
// Start the TCP listener and listen for connections
tlsClient.Start();
// The while loop will check for true in this before checking for connections
ServRunning = true;
// Start the new tread that hosts the listener
thrListener = new Thread(KeepListening);
thrListener.Start();
}
private void KeepListening()
{
// While the server is running
while (ServRunning == true)
{
// Accept a pending connection
tcpClient = tlsClient.AcceptTcpClient();
// Create a new instance of Connection
Connection newConnection = new Connection(tcpClient);
}
}
}
// This class handels connections; there will be as many instances of it as there will be connected users
class Connection
{
TcpClient tcpClient;
// The thread that will send information to the client
private Thread thrSender;
private StreamReader srReceiver;
private StreamWriter swSender;
private string currUser;
private string strResponse;
// The constructor of the class takes in a TCP connection
public Connection(TcpClient tcpCon)
{
tcpClient = tcpCon;
// The thread that accepts the client and awaits messages
thrSender = new Thread(AcceptClient);
// The thread calls the AcceptClient() method
thrSender.Start();
}
private void CloseConnection()
{
// Close the currently open objects
tcpClient.Close();
srReceiver.Close();
swSender.Close();
}
// Occures when a new client is accepted
private void AcceptClient()
{
srReceiver = new System.IO.StreamReader(tcpClient.GetStream());
swSender = new System.IO.StreamWriter(tcpClient.GetStream());
// Read the account information from the client
currUser = srReceiver.ReadLine();
// We got a response from the client
if (currUser != "")
{
// Store the user name in the hash table
if (ChatServer.htUsers.Contains(currUser) == true)
{
// 0 means not connected
swSender.WriteLine("0|This username already exists.");
swSender.Flush();
CloseConnection();
return;
}
else if (currUser == "Administrator")
{
// 0 means not connected
swSender.WriteLine("0|This username is reserved.");
swSender.Flush();
CloseConnection();
return;
}
else
{
// 1 means connected successfully
swSender.WriteLine("1");
swSender.Flush();
// Add the user to the hash tables and start listening for messages from him
ChatServer.AddUser(tcpClient, currUser);
}
}
else
{
CloseConnection();
return;
}
try
{
// Keep waiting for a message from the user
while ((strResponse = srReceiver.ReadLine()) != "")
{
// If it's invalid, remove the user
if (strResponse == null)
{
ChatServer.RemoveUser(tcpClient);
}
else
{
// Otherwise send the message to all the other users
ChatServer.SendMessage(currUser, strResponse);
}
}
}
catch
{
// If anything went wrong with this user, disconnect him
ChatServer.RemoveUser(tcpClient);
}
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Threading;
namespace ChatClient
{
public partial class Form1 : Form
{
// Will hold the user name
private string UserName = "Unknown";
private StreamWriter swSender;
private StreamReader srReceiver;
private TcpClient tcpServer;
// Needed to update the form with messages from another thread
private delegate void UpdateLogCallback(string strMessage);
// Needed to set the form to a "disconnected" state from another thread
private delegate void CloseConnectionCallback(string strReason);
private Thread thrMessaging;
private IPAddress ipAddr;
private bool Connected;
public Form1()
{
// On application exit, don't forget to disconnect first
Application.ApplicationExit += new EventHandler(OnApplicationExit);
InitializeComponent();
}
// The event handler for application exit
public void OnApplicationExit(object sender, EventArgs e)
{
if (Connected == true)
{
// Closes the connections , sr sw and dispose and abort threading
Connected = false;
srReceiver.Close();
srReceiver.Dispose();
thrMessaging.Abort();
swSender.Close();
swSender.Dispose();
tcpServer.Close();
}
}
private void btnConnect_Click(object sender, EventArgs e)
{
// If we are not currently connected but awaiting to connect
if (Connected == false)
{
// Initialize the connection
InitializeConnection();
}
else // We are connected, thus disconnect
{
CloseConnection("Disconnected at user's request.");
}
}
private void InitializeConnection()
{
// Parse the IP address from the TextBox into an IPAddress object
try
{
ipAddr = IPAddress.Parse(txtIp.Text);
try
{
// Start a new TCP connections to the chat server
tcpServer = new TcpClient();
tcpServer.Connect(ipAddr, 1986);
//altered POSITION
// Helps us track whether we're connected or not
Connected = true;
// Prepare the form
UserName = txtUser.Text;
if (UserName == null)
{
UserName = "Unknown";
}
// Disable and enable the appropriate fields
txtIp.Enabled = false;
txtUser.Enabled = false;
txtMessage.Enabled = true;
btnSend.Enabled = true;
btnConnect.Text = "Disconnect";
// Send the desired username to the server
swSender = new StreamWriter(tcpServer.GetStream());
swSender.WriteLine(txtUser.Text);
swSender.Flush();
// Start the thread for receiving messages and further communication
thrMessaging = new Thread(new ThreadStart(ReceiveMessages));
thrMessaging.Start();
}
catch (SocketException ex)
{
MessageBox.Show("There is no server at " + txtIp.Text + " or Server is Down");
//Close connection
tcpServer.Close();
txtIp.Text = null;
}
catch (Exception ex)
{
MessageBox.Show("Error has occured");
//Close connection
tcpServer.Close();
txtIp.Text = null;
}
}
catch (Exception ex)
{
MessageBox.Show(" IP Address typed is an incorrect format ");
}
//ORIGINAL POSITION OF THIS
}
private void ReceiveMessages()
{
// Receive the response from the server
srReceiver = new StreamReader(tcpServer.GetStream());
// If the first character of the response is 1, connection was successful
string ConResponse = srReceiver.ReadLine();
// If the first character is a 1, connection was successful
if (ConResponse[0] == '1')
{
// Update the form to tell it we are now connected
this.Invoke(new UpdateLogCallback(this.UpdateLog), new object[] { "Connected Successfully!" });
}
else // If the first character is not a 1 (probably a 0), the connection was unsuccessful
{
string Reason = "Not Connected: ";
// Extract the reason out of the response message. The reason starts at the 3rd character
Reason += ConResponse.Substring(2, ConResponse.Length - 2);
// Update the form with the reason why we couldn't connect
this.Invoke(new CloseConnectionCallback(this.CloseConnection), new object[] { Reason });
// Exit the method
return;
}
// While we are successfully connected, read incoming lines from the server
while (Connected)
{
// Show the messages in the log TextBox
this.Invoke(new UpdateLogCallback(this.UpdateLog), new object[] { srReceiver.ReadLine() });
}
}
// This method is called from a different thread in order to update the log TextBox
private void UpdateLog(string strMessage)
{
// update text amd scroll TextBox to the bottom
txtLog.AppendText(strMessage + "\r\n");
txtLog.ScrollToCaret();
}
// Closes a current connection
private void CloseConnection(string Reason)
{
// Show the reason why the connection is ending
txtLog.AppendText(Reason + "\r\n");
// Enable and disable the appropriate controls on the form
txtIp.Enabled = true;
txtUser.Enabled = true;
txtMessage.Enabled = false;
btnSend.Enabled = false;
btnConnect.Text = "Connect";
thrMessaging.Abort();
// Close the objects original
//Connected = false;
// swSender.Close();
// srReceiver.Close();
// tcpServer.Close();
// thrMessaging.Abort();
Connected = false;
srReceiver.Close();
srReceiver.Dispose();
thrMessaging.Abort();
swSender.Close();
swSender.Dispose();
tcpServer.Close();
}
// Sends the message typed in to the server
private void SendMessage()
{
if (txtMessage.Lines.Length >= 1)
{
swSender.WriteLine(txtMessage.Text);
swSender.Flush();
txtMessage.Lines = null;
}
txtMessage.Text = "";
}
// We want to send the message when the Send button is clicked
private void btnSend_Click(object sender, EventArgs e)
{
SendMessage();
}
// But we also want to send the message once Enter is pressed
private void txtMessage_KeyPress(object sender, KeyPressEventArgs e)
{
// If the key is Enter
if (e.KeyChar == (char)13)
{
SendMessage();
}
}
private void Form1_Load(object sender, EventArgs e)
{
}
private void textBox1_TextChanged(object sender, EventArgs e)
{
}
}
}
index > .NET Framework Networking and Communication > Trying to implement whisper / private messaging functionality into a socket server/client chat program