public async Task Connect()
{
await Task.Run(async() =>
{
await TryConnect();
Task.Run(() =>
{
try
{
while (true)
{
var line = reader.ReadLine();
if (line == null)
{
continue;
}
var msg = (Message)JsonSerializer.DeserializeFromString <Message>(line.Trim('\0'));
if (msg == null)
{
continue;
}
if (msg.Verb == "ConnectionStatus")
{
var status = JsonSerializer.DeserializeFromString <bool>(msg.Object);
IsConnectedWithHospitalServer = status;
continue;
}
OnMessage(msg);
if (!_websocketOnActionsT.ContainsKey(msg.Verb))
{
continue;
}
foreach (var action in _websocketOnActionsT[msg.Verb])
{
try
{
var obj = JsonSerializer.DeserializeFromString(msg.Object, action.Type);
action.Action(obj);
}
catch (Exception ex)
{
if (Debugger.IsAttached)
{
throw ex;
}
}
}
}
}
catch
{
IsConnectedWithHospitalServer = false;
}
client.Close();
Connect();
});
});
}
public object Get(string key)
{
var item = MongoCollection
.FindOneAs <CachedItem>(Query.EQ("_id", new BsonString(key)));
var type = Type.GetType(item.ValueType);
return(JsonSerializer.DeserializeFromString(item.Value, type));
}
private void ServiceStackBechmark <T>(T obj, int count)
{
return;
try
{
long initlength = 0;
Stopwatch sw;
//-----------------------------------
var sstSerializer = new ServiceStack.Text.JsonSerializer <T>();
var initSerialized = sstSerializer.SerializeToString(obj);
initlength = initSerialized.Length;
sstSerializer.DeserializeFromString(initSerialized);
using (var sharperMem = new MemoryStream())
{
sw = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
sstSerializer.SerializeToString(obj);
}
}
sw.Stop();
Log("ServiceStackText Serialize took: "+ ToString(sw.Elapsed) + " data-size: " + initlength);
sw = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
sstSerializer.DeserializeFromString(initSerialized);
}
sw.Stop();
Log("ServiceStackText Deserialize took: "+ ToString(sw.Elapsed));
}
catch (Exception ex)
{
Log("ServiceStackText failed, " + ex.Message);
}
}
public static void RunServiceStackJsonParser <T>(T item, int count)
where T : class
{
// Warm-up
var serializer = new ServiceStack.Text.JsonSerializer <T>();
var json = ServiceStack.Text.JsonSerializer.SerializeToString(item);
var root = serializer.DeserializeFromString(json);
var t = new Stopwatch();
t.Start();
for (var i = 0; i < count; i++)
{
root = serializer.DeserializeFromString(json);
}
t.Stop();
var time = t.Elapsed.TotalMilliseconds * 1000;
Console.WriteLine("ServiceStack Parser: {0}µs", time);
}
public static T FromJsonInFile <T>(string path)
{
string data;
using (var stream = File.OpenRead(path))
using (var sr = new StreamReader(stream))
{
data = sr.ReadToEnd();
}
return(JsonSerializer.DeserializeFromString <T>(data));
}
public T Get <T>(string key) where T : class
{
var item = MongoCollection
.FindOneAs <CachedItem>(Query.EQ("_id", new BsonString(key)));
if (item == null)
{
return(null);
}
return(CheckItemExpired(item)
? null
: JsonSerializer.DeserializeFromString <T>(item.Value));
}
private void InvokeCall(Message msg)
{
try
{
var payload = System.Text.Encoding.UTF8.GetString(msg.payload);
var ser = new ServiceStack.Text.JsonSerializer <Dictionary <string, object> >();
var ht = ser.DeserializeFromString(payload);
//var ht = JsonConvert.DeserializeObject<Hashtable>(payload, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Include, FloatParseHandling = FloatParseHandling.Decimal });
localMethods[msg.target_operation_guid].method(ht, (err, resp) =>
{
if (err != null)
{
var errRespMsg = new Message
{
cmd = Message.Cmd.ERROR_RESPONSE,
source_component_guid = guid,
target_operation_guid = msg.source_operation_guid,
payload = stringToByteArray(err)
};
publisher.Publish(msg.source_component_guid, ref errRespMsg);
return;
}
var respMsg = new Message
{
cmd = Message.Cmd.RESPONSE,
source_component_guid = guid,
target_operation_guid = msg.source_operation_guid,
payload = resp
};
publisher.Publish(msg.source_component_guid, ref respMsg);
return;
});
}
catch (Exception e)
{
var respMsg = new Message
{
cmd = Message.Cmd.ERROR_RESPONSE,
source_component_guid = guid,
target_operation_guid = msg.source_operation_guid,
payload = stringToByteArray(String.Format("Exception: {0}", e.ToString()))
};
publisher.Publish(msg.source_component_guid, ref respMsg);
}
}
public static T ToObject <T>(this string obj)
{
return(JsonSerializer.DeserializeFromString <T>(obj));
}
public static object FromJson(string data, Type type)
{
return(JsonSerializer.DeserializeFromString(data, type));
}
public static T FromJson <T>(string data)
{
return(JsonSerializer.DeserializeFromString <T>(data));
}
public T Deserialize <T>(string json)
{
return(JsonSerializer.DeserializeFromString <T>(json));
}
private void InvokeCall(Message msg)
{
try
{
var payload = System.Text.Encoding.UTF8.GetString(msg.payload);
var ser = new ServiceStack.Text.JsonSerializer<Dictionary<string, object>>();
var ht = ser.DeserializeFromString(payload);
//var ht = JsonConvert.DeserializeObject<Hashtable>(payload, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Include, FloatParseHandling = FloatParseHandling.Decimal });
localMethods[msg.target_operation_guid].method(ht, (err, resp) =>
{
if (err != null)
{
var errRespMsg = new Message
{
cmd = Message.Cmd.ERROR_RESPONSE,
source_component_guid = guid,
target_operation_guid = msg.source_operation_guid,
payload = stringToByteArray(err)
};
publisher.Publish(msg.source_component_guid, ref errRespMsg);
return;
}
var respMsg = new Message
{
cmd = Message.Cmd.RESPONSE,
source_component_guid = guid,
target_operation_guid = msg.source_operation_guid,
payload = resp
};
publisher.Publish(msg.source_component_guid, ref respMsg);
return;
});
}
catch (Exception e)
{
var respMsg = new Message
{
cmd = Message.Cmd.ERROR_RESPONSE,
source_component_guid = guid,
target_operation_guid = msg.source_operation_guid,
payload = stringToByteArray(String.Format("Exception: {0}", e.ToString()))
};
publisher.Publish(msg.source_component_guid, ref respMsg);
}
}
public object Deserialize(string data, System.Type type)
{
return(Serializer.DeserializeFromString(data, type));
}
/// <summary>
/// Deserializes string into an object
/// </summary>
/// <typeparam name="T">Type of object to serialize to</typeparam>
/// <param name="data">Serialized object</param>
/// <returns>Object of type T</returns>
public T Deserialize <T>(string data)
{
return(Serializer.DeserializeFromString <T>(data));
}