public object RetriveResource(string name, Type t)
{
DelayedResult result = new DelayedResult()
{
Name = name
};
_Messages.Add(new Message(MessageType.RequestResource, result));
result.Lock.Wait();
result.Lock.Dispose();
return(result.Data);
}
public object RetriveResource(string name, Type t)
{
DelayedResult result = new DelayedResult() { Name = name };
this.Messages.Add( new Message( MessageType.RequestResource, result ) );
result.Lock.Wait();
result.Lock.Dispose();
return result.Data;
}
private bool ProcessMessage(BinaryWriter writer, BinaryFormatter outputFormat, Message message)
{
switch (message.Type)
{
case MessageType.PostComplete:
{
writer.Write((Int32)MessageType.PostComplete);
}
break;
case MessageType.PostResource:
{
var data = message.Data as Result;
writer.Write(data.Name);
outputFormat.Serialize(writer.BaseStream, data.Data);
}
break;
case MessageType.PostProgess:
{
writer.Write((Int32)MessageType.PostProgess);
writer.Write(_Progress);
writer.Flush();
}
break;
case MessageType.RequestResource:
{
var dr = message.Data as DelayedResult;
ResourceRequests.AddLast(dr);
writer.Write((Int32)MessageType.RequestResource);
writer.Write(dr.Name);
writer.Flush();
}
break;
case MessageType.ReturningResource:
{
var result = message.Data as Result;
DelayedResult toRemove = null;
foreach (var delayed in ResourceRequests)
{
if (delayed.Name == result.Name)
{
toRemove = delayed;
delayed.Data = result.Data;
delayed.Lock.Release();
break;
}
}
if (toRemove != null)
{
ResourceRequests.Remove(toRemove);
}
}
break;
case MessageType.PostCancel:
{
var ms = _CurrentRunningModelSystem;
// if we don't have a model system then we are done
if (ms == null)
{
break;
}
try
{
// try to cancel the model system
ms.ExitRequest();
}
catch
{
}
}
break;
case MessageType.SendModelSystem:
try
{
var mssBuff = message.Data as byte[];
IModelSystemStructure mss = null;
using (MemoryStream memory = new MemoryStream())
{
memory.Write(mssBuff, 0, mssBuff.Length);
memory.Position = 0;
mss = ModelSystemStructure.Load(memory, _Configuration);
}
if (_ModelSystemThread != null && _ModelSystemThread.IsAlive)
{
try
{
_ModelSystemThread.Abort();
}
catch
{
}
}
// now that the other thread is going to end
// we can now go and start generating ourselves
// in another run thread
(_ModelSystemThread =
new Thread(ModelSystemStartup)).Start(mss);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
return(true);
}
break;
case MessageType.WriteToHostConsole:
writer.Write((int)MessageType.WriteToHostConsole);
writer.Write(message.Data as string);
break;
case MessageType.SendCustomMessage:
{
var msg = message.Data as SendCustomMessageMessage;
int msgNumber = msg.CustomMessageNumber;
int length = 0;
var failed = false;
byte[] buffer = null;
Action <object, Stream> customConverter;
bool getConverter = false;
lock (this)
{
getConverter = _CustomSenders.TryGetValue(msgNumber, out customConverter);
}
if (getConverter)
{
using (MemoryStream mem = new MemoryStream(0x100))
{
try
{
customConverter(msg.Data, mem);
mem.Position = 0;
buffer = mem.ToArray();
length = buffer.Length;
}
catch
{
failed = true;
}
}
}
writer.Write((Int32)MessageType.SendCustomMessage);
writer.Write((Int32)msg.CustomMessageNumber);
writer.Write((Int32)length);
if (!failed)
{
writer.Write(buffer, 0, length);
buffer = null;
}
}
break;
case MessageType.ReceiveCustomMessage:
{
var msg = message.Data as ReceiveCustomMessageMessage;
var customNumber = msg.CustomMessageNumber;
Func <Stream, object> customConverter;
bool getConverted = false;
lock (this)
{
getConverted = _CustomReceivers.TryGetValue(customNumber, out customConverter);
}
if (getConverted)
{
using (var stream = msg.Stream)
{
try
{
object output = customConverter(stream);
if (_CustomHandlers.TryGetValue(msg.CustomMessageNumber, out List <Action <object> > handlers))
{
foreach (var handler in handlers)
{
try
{
handler(output);
}
catch (Exception e)
{
Console.WriteLine(e.Message + "\r\n" + e.StackTrace);
}
}
}
}
catch
{
}
}
}
}
break;
default:
// FAIL!
Console.WriteLine("Processing a message of type " + message.Type + " and we didn't know what to do with it.");
return(true);
}
return(false);
}
