public override void AfterCommit (string key, Raven.Json.Linq.RavenJObject document, Raven.Json.Linq.RavenJObject metadata, Guid etag)
{
using (var sw = new StreamWriter (File.Open ("c:\\test", FileMode.OpenOrCreate)))
{
sw.Write (metadata["Raven-Clr-Type"] + Environment.NewLine);
base.AfterCommit (key, document, metadata, etag);
if (metadata["Raven-Clr-Type"].ToString() == "DynamicHub.DynamicRule, DynamicHub")
{
var doc = document.ToString(Formatting.None);
var dr = new ServiceStack.Text.JsonSerializer<DynamicRule>().DeserializeFromString(doc);
var ass = CodeDomProvider.CreateProvider("CSharp")
.CompileAssemblyFromSource(
new CompilerParameters
{
GenerateInMemory = false,
GenerateExecutable = false,
IncludeDebugInformation = false,
OutputAssembly = "TestAssembly",
},
new[]
{
@"",
@""
}).CompiledAssembly;
sw.Write(document.ToString());
}
}
}
public static string ToJson <T>(T entity, bool format = true)
{
return(format
// pretty or...
? JsonConvert.SerializeObject(entity, Formatting.Indented)
// fast!
: JsonSerializer.SerializeToString(entity));
}
private static List <string> SerializeWithServiceStack <T>(List <T> objects)
{
var serializer = new ServiceStack.Text.JsonSerializer <T>();
var jsonStrings = objects.Select(serializer.SerializeToString).ToList();
return(jsonStrings);
}
private static List <T> DeserializeWithServiceStack <T>(List <string> jsonStrings)
{
var serializer = new ServiceStack.Text.JsonSerializer <T>();
var objects = jsonStrings.Select(serializer.DeserializeFromString).ToList();
return(objects);
}
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));
}
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));
}
private async Task CreateCognitoSecretFileAsync()
{
foreach (var cognitoClient in this._configSettings.ExtraAWSConfig.CognitoClients)
{
cognitoClient.ClientSecret = await _awsCognitoHelper.GetClientSecretForAppClientAsync(cognitoClient)
.ConfigureAwait(false);
}
await FileHelper.CreateFileWithContentAsync(Path.Combine(this._configSettings.SecretsDockerFolderPath,
this._configSettings.ExtraAWSConfig.CognitoSecretsFileName),
JsonSerializer.SerializeToString(this._configSettings.ExtraAWSConfig.CognitoClients))
.ConfigureAwait(false);
}
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);
}
}
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);
}
/// <summary>
/// Deserializes stream into an object
/// </summary>
/// <typeparam name="T">Type of object to serialize to</typeparam>
/// <param name="stream">Stream to deserialize from</param>
/// <returns>Object of type T</returns>
public T Deserialize <T>(Stream stream) where T : class
{
return(Serializer.DeserializeFromStream <T>(stream));
}
public static T ToObject <T>(this string obj)
{
return(JsonSerializer.DeserializeFromString <T>(obj));
}
public static string ToJson(this object obj)
{
return(JsonSerializer.SerializeToString(obj));
}
public static object FromJson(string data, Type type)
{
return(JsonSerializer.DeserializeFromString(data, type));
}
public object Deserialize(string data, System.Type type)
{
return(Serializer.DeserializeFromString(data, type));
}
/// <summary>
/// Serializes object to a stream
/// </summary>
/// <param name="obj">Object to serialize</param>
/// <param name="stream">Stream to serialize to</param>
public void Serialize <T>(T obj, Stream stream)
{
Serializer.SerializeToStream(obj, stream);
}
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 string ServiceStack_Serialize()
{
return(JsonSerializer.SerializeToString(RootSampleObject));
}
private static void SerializeServiceStack(int count)
{
var s2 = new ServiceStack.Text.JsonSerializer<SimpleObject>();
var m = new MemoryStream(8000);
for (int i = 0; i < count; i++)
{
var t = new StreamWriter(m);
s2.SerializeToWriter(testData, t);
t.Flush();
m.Position = 0;
}
}
/// <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));
}
public T Deserialize <T>(string json)
{
return(JsonSerializer.DeserializeFromString <T>(json));
}
public static T FromJson <T>(string data)
{
return(JsonSerializer.DeserializeFromString <T>(data));
}
public string Serialize(object obj)
{
return(JsonSerializer.SerializeToString(obj));
}
/// <summary>
/// Serializes object to a string
/// </summary>
/// <param name="obj">Object to serialize</param>
/// <returns>Serialized string of the object</returns>
public string Serialize <T>(T obj)
{
return(Serializer.SerializeToString(obj));
}
