private void Receiver_ClientDataReceived(object sender, System.ComponentModel.AsyncCompletedEventArgs e)
{
if (e.Error == null)
{
ReceiveData data = e.UserState as ReceiveData;
if (data != null)
{
MessageData messageData = data.clientData;
if (messageData != null && messageData.id > 0)
{
Console.WriteLine("received Message Type: {0}", messageData.id);
if (MyClient != null)
{
Console.WriteLine("\tFrom Client: {0}", data.clientHandle);
// It's a string message, so just print it out for now.
Console.WriteLine("[{0}]: {1} ", messageData.name, ((messageData.message is string) ? messageData.message : ((messageData.message as byte[]).Length + " bytes")));
}
if (MessageFactory != null)
{
IMessageImpl msgImpl = MessageFactory.MakeMessageImpl(messageData.id, MyClient.ClientHandle);
if (msgImpl != default(IMessageImpl))
{
msgHandler.Handle(MyClient, messageData, msgImpl, this);
}
}
}
}
}
}
private void HandleGetUserName(Client client, MessageData messageData)
{
Console.WriteLine("Handle User Name Register.");
try
{
// Register the name
_server.ClientHandleToUserName.Add(client.ClientHandle, (string)messageData.name);
MessageData msg = new MessageData();
msg.handle = messageData.handle;
msg.id = 1;
msg.name = messageData.name;
msg.response = false;
msg.message = String.Format("[{0}] has joined and says \'{1}\'.", messageData.name, messageData.message);
IMessageImpl impl = MessageImplFactory.Instance().MakeMessageImpl((int)MessageImplFactory.MessageFactoryTypesEnum.GLOBAL_MSG_TYPE, client.ClientHandle);
if (impl != default(IMessageImpl))
{
_server.MessageHandler.Handle(client, msg, impl, _server);
//HandleGlobalMessageSendAsync(client, msg);
}
}
catch (Exception e)
{
Console.WriteLine("Client already registered a Name?: " + e.Message);
}
}
public bool Handle(Client client, MessageData message, IMessageImpl action, object handlerArgs)
{
if (client == null || message == null)
{
return(false);
}
bool retVal = false;
//lock (lockObj)
//{
//IMessageHandler handler = GetMessageHandler();
//if (handler != default(IMessageHandler))
//{
SetHandlerData(handlerArgs, action);
retVal = HandleMessage(client, message, action);
//}
//}
return(retVal);
}
public IMessageImpl GetMessageImpl(int msgId)
{
MessageTypeEnum msgType = MessageTypeEnum.MSG_TYPE_UNINIT;
IMessageImpl impl = default(IMessageImpl);
if (Enum.TryParse(msgId.ToString(), out msgType))
{
switch (msgType)
{
case MessageTypeEnum.MSG_TYPE_DEFAULT:
impl = new DefaultMessageImpl();
break;
case MessageTypeEnum.MSG_TYPE_UNINIT:
default:
Console.WriteLine("Unhandled message type: " + msgType);
break;
}
}
return(impl);
}
private bool HandleClientExit(Client client, MessageData messageData)
{
bool handleExit = false;
try
{
MessageData msg = new MessageData();
msg.handle = messageData.handle;
msg.id = 1;
msg.name = messageData.name;
msg.response = false;
msg.message = String.Format("[{0}] has left.", messageData.name);
IMessageImpl impl = MessageImplFactory.Instance().MakeMessageImpl((int)MessageImplFactory.MessageFactoryTypesEnum.GLOBAL_MSG_TYPE, client.ClientHandle);
if (impl != default(IMessageImpl))
{
handleExit = _server.MessageHandler.Handle(client, msg, impl, _server);
}
if (handleExit)
{
// Remove client handle record keeping
var remHandle = _server.ClientHandleToUserName.Remove(client.ClientHandle);
// Remove the client impls
var remImpl = MessageImplFactory.Instance().RemoveClient(client.ClientHandle);
// Remove the client object
var remClient = ClientStore.RemoveClient(client.ClientHandle);
return(remHandle && remImpl && remClient);
}
}
catch (Exception ex)
{
Console.WriteLine("Client Handle Remove Exception: " + ex.Message);
handleExit = false;
}
return(handleExit);
}
public override void SetHandlerData(object data, IMessageImpl action)
{
action.SetActionData(data);
}
public override bool HandleMessage(Client client, MessageData messageData, IMessageImpl action)
{
return(action.PerformAction(client, messageData));
}
abstract public void SetHandlerData(object data, IMessageImpl action);
abstract public bool HandleMessage(Client client, MessageData messageData, IMessageImpl action);
/// <summary>
/// Interface implementation to create the Impls that provide the actions to
/// received messages.
/// </summary>
/// <param name="msgType">The incoming message type</param>
/// <param name="clientHandle">The client that sent the message</param>
/// <returns>IMessageImpl</returns>
public IMessageImpl MakeMessageImpl(int msgType, long clientHandle)
{
IMessageImpl impl = default;
bool success = Enum.TryParse(msgType.ToString(), out MessageFactoryTypesEnum msgFactoryType);
Console.WriteLine("Getting IMPL for Client: {0}; TASK: {1}", clientHandle, msgType.ToString());
if (!success)
{
return(impl);
}
// The stored client impls we're looking to reuse. New clients are created and
// stored further below.
Dictionary <MessageFactoryTypesEnum, IMessageImpl> client;
// The success block. If we have a client already and it has the impl,
// just return the impl for re-use.
bool clientFound = implStore.TryGetValue(clientHandle, out client);
if (clientFound)
{
if (client.TryGetValue(msgFactoryType, out impl))
{
Console.WriteLine("Found Client: {0}", clientHandle);
return(impl);
}
}
// The not found block. We have to create a new impl regardless. We may have
// found a client already. Add the impl if we have. If not, create a new one
// and add it to the impl Store.
try
{
impl = GetMessageImpl(msgType);
if (impl == default(IMessageImpl))
{
return(impl);
}
lock (lockObj)
{
if (!clientFound)
{
client = new Dictionary <MessageFactoryTypesEnum, IMessageImpl>
{
{ msgFactoryType, impl }
};
implStore.Add(clientHandle, client);
Console.WriteLine("Added Client: {0}", clientHandle);
return(impl);
}
// We have a client Add the impl.
client.Add(msgFactoryType, impl);
Console.WriteLine("Added Task: {0} to Client: {1}", msgType.ToString(), clientHandle);
}
}
catch (Exception e)
{
Console.WriteLine("ImplFactory Exception: " + e.Message);
impl = default;
}
return(impl);
}
