public static void Serialize(object target, bool prettyPrint, System.IO.TextWriter pOutput, string callback)
{
Newtonsoft.Json.JsonSerializer ser = new Newtonsoft.Json.JsonSerializer();
ser.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
ser.Formatting = prettyPrint ? Newtonsoft.Json.Formatting.Indented : Newtonsoft.Json.Formatting.None;
ser.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
if (string.IsNullOrEmpty(callback))
{
ser.Serialize(pOutput, target);
return;
}
// typeof foobar != 'undefined' ? foobar(bla) : alert('Callback-Funktion "foobar" undefiniert...');
pOutput.Write("typeof ");
pOutput.Write(callback);
pOutput.Write(" != 'undefined' ? ");
pOutput.Write(callback);
pOutput.Write("(");
ser.Serialize(pOutput, target);
pOutput.Write(")");
pOutput.Write(" : alert('Callback-Funktion \"");
pOutput.Write(callback);
pOutput.Write("\" undefiniert...');");
}
protected Task Serialize(Dictionary <string, object> parameters, bool wrapped, bool ordered)
{
var serializer = new Newtonsoft.Json.JsonSerializer();
if (ordered)
{
serializer.ContractResolver = new OrderedContractResolver();
}
serializer.Converters.Add(new SDTConverter());
TextWriter ms = new StringWriter();
if (parameters.Count == 1 && !wrapped) //In Dataproviders, with one parameter BodyStyle is WebMessageBodyStyle.Bare, Both requests and responses are not wrapped.
{
string key = parameters.First().Key;
using (var writer = new Newtonsoft.Json.JsonTextWriter(ms))
{
serializer.Serialize(writer, parameters[key]);
}
}
else
{
using (var writer = new Newtonsoft.Json.JsonTextWriter(ms))
{
serializer.Serialize(writer, parameters);
}
}
_httpContext.Response.Write(ms.ToString()); // Use intermediate StringWriter in order to avoid chunked response
return(Task.CompletedTask);
}
public void Save()
{
List <WebcamFullScreen> wfs = new List <WebcamFullScreen>();
List <VUMeter> meters = new List <VUMeter>();
foreach (Job j in toProcess)
{
if (j.GetType() == typeof(WebcamFullScreen))
{
wfs.Add((WebcamFullScreen)j);
}
if (j.GetType() == typeof(VUMeter))
{
meters.Add((VUMeter)j);
}
}
Newtonsoft.Json.JsonSerializer s = new Newtonsoft.Json.JsonSerializer();
using (System.IO.StreamWriter sw = new System.IO.StreamWriter("settingswebcam.txt"))
using (Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(sw))
{
s.Serialize(writer, wfs);
// {"ExpiryDate":new Date(1230375600000),"Price":0}
}
using (System.IO.StreamWriter sw2 = new System.IO.StreamWriter("settingsvumeter.txt"))
using (Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(sw2))
{
s.Serialize(writer, meters);
// {"ExpiryDate":new Date(1230375600000),"Price":0}
}
}
static void Main(string[] args)
{
Write("Input format of serialization (json/xml/binary):");
string serializationFormat = ReadLine();
using (DbNorthwind db = new DbNorthwind()){
List <Category> categories = db.Categories.ToList();
List <Product> products = db.Products.ToList();
switch (serializationFormat)
{
case ("json"):
Newtonsoft.Json.JsonSerializer jsonSerializer = new Newtonsoft.Json.JsonSerializer();
using (StreamWriter file = File.CreateText("Categories.json"))
{
jsonSerializer.Serialize(file, categories);
}
using (StreamWriter file = File.CreateText("Products.json"))
{
jsonSerializer.Serialize(file, products);
}
break;
case ("xml"):
XmlSerializer xmlSerializerCategories = new XmlSerializer(typeof(List <Category>));
XmlSerializer xmlSerializerProducts = new XmlSerializer(typeof(List <Product>));
using (FileStream file = File.Create("Categories.xml"))
{
xmlSerializerCategories.Serialize(file, categories);
}
using (FileStream file = File.Create("Products.xml"))
{
xmlSerializerProducts.Serialize(file, products);
}
break;
case ("binary"):
BinaryFormatter binarySerializer = new BinaryFormatter();
using (FileStream file = File.Create("Categories.dat"))
{
binarySerializer.Serialize(file, categories);
}
using (FileStream file = File.Create("Products.dat"))
{
binarySerializer.Serialize(file, products);
}
break;
default:
WriteLine("Unknown format of serialization");
break;
}
}
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object untypedValue, Newtonsoft.Json.JsonSerializer serializer)
{
if (untypedValue == null)
{
serializer.Serialize(writer, null);
return;
}
var value = (long)untypedValue;
serializer.Serialize(writer, value.ToString());
return;
}
public void NewtonsoftJsonSerializeDeserializeBenchmark()
{
var serializer = new Newtonsoft.Json.JsonSerializer()
{
DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
};
int runs = 50000;
DateTime start, stop;
MessageModel msg = null;
start = DateTime.UtcNow;
for (int i = 0; i < runs; i++)
{
var writer = new StringWriter();
serializer.Serialize(writer, SimpleMessage);
var reader = new StringReader(writer.ToString());
var jsonReader = new Newtonsoft.Json.JsonTextReader(reader);
var dtoMsg = serializer.Deserialize <MessageDtoModelV1>(jsonReader);
}
stop = DateTime.UtcNow;
Assert.AreEqual(ComplexMessage, msg);
var total = (stop - start).TotalMilliseconds;
Console.WriteLine(
"NewtonsoftJsonSerialize+Deserialize(Simple): avg: {0:0.00} ms runs: {1} took: {2:0.00} ms",
total / runs,
runs,
total
);
start = DateTime.UtcNow;
for (int i = 0; i < runs; i++)
{
var writer = new StringWriter();
serializer.Serialize(writer, ComplexMessage);
var reader = new StringReader(writer.ToString());
var jsonReader = new Newtonsoft.Json.JsonTextReader(reader);
var dtoMsg = serializer.Deserialize <MessageDtoModelV1>(jsonReader);
}
stop = DateTime.UtcNow;
Assert.AreEqual(ComplexMessage, msg);
total = (stop - start).TotalMilliseconds;
Console.WriteLine(
"NewtonsoftJsonSerialize+Deserialize(ComplexMessage): avg: {0:0.00} ms runs: {1} took: {2:0.00} ms",
total / runs,
runs,
total
);
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
var hasValue = (bool)value.GetType().GetProperty(nameof(Maybe <object> .HasValue)).GetValue(value);
if (hasValue)
{
var underlyingValue = value.GetType().GetProperty(nameof(Maybe <object> .Value)).GetValue(value);
serializer.Serialize(writer, underlyingValue);
}
else
{
serializer.Serialize(writer, null);
}
}
public Message SerializeRequest(MessageVersion messageVersion, object[] parameters)
{
byte[] body;
Newtonsoft.Json.JsonSerializer serializer = endpoint.NewtonsoftSettings().JsonSerializer;
using (MemoryStream ms = new MemoryStream())
{
using (StreamWriter sw = new StreamWriter(ms, Encoding.UTF8))
{
using (Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(sw))
{
if (parameters.Length == 1)
{
// Single parameter, assuming bare
serializer.Serialize(sw, parameters[0]);
}
else
{
writer.WriteStartObject();
for (int i = 0; i < this.operation.Messages[0].Body.Parts.Count; i++)
{
writer.WritePropertyName(this.operation.Messages[0].Body.Parts[i].Name);
serializer.Serialize(writer, parameters[i]);
}
writer.WriteEndObject();
}
writer.Flush();
sw.Flush();
body = ms.ToArray();
}
}
}
if (traceSource.Switch.ShouldTrace(TraceEventType.Information))
{
traceSource.TraceEvent(TraceEventType.Information, 1004, System.Text.Encoding.UTF8.GetString(body));
}
Message requestMessage = Message.CreateMessage(messageVersion, operation.Messages[0].Action, new RawBodyWriter(body));
requestMessage.Headers.To = operationUri;
requestMessage.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Raw));
HttpRequestMessageProperty reqProp = new HttpRequestMessageProperty();
reqProp.Headers[HttpRequestHeader.ContentType] = "application/json";
requestMessage.Properties.Add(HttpRequestMessageProperty.Name, reqProp);
return(requestMessage);
}
public void Serialize(Stream outputStream, object data, Type type = null)
{
var formatter = new Newtonsoft.Json.JsonSerializer();
using (var writer = new StreamWriter(outputStream, Utf8WithoutBom, _streamBuffer, true))
formatter.Serialize(writer, data);
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
var exception = value as System.Exception;
if (exception != null)
{
var resolver = serializer.ContractResolver as Newtonsoft.Json.Serialization.DefaultContractResolver ?? _defaultContractResolver;
var jObject = new Newtonsoft.Json.Linq.JObject();
jObject.Add(resolver.GetResolvedPropertyName("discriminator"), exception.GetType().Name);
jObject.Add(resolver.GetResolvedPropertyName("Message"), exception.Message);
jObject.Add(resolver.GetResolvedPropertyName("StackTrace"), _hideStackTrace ? "HIDDEN" : exception.StackTrace);
jObject.Add(resolver.GetResolvedPropertyName("Source"), exception.Source);
jObject.Add(resolver.GetResolvedPropertyName("InnerException"),
exception.InnerException != null ? Newtonsoft.Json.Linq.JToken.FromObject(exception.InnerException, serializer) : null);
foreach (var property in GetExceptionProperties(value.GetType()))
{
var propertyValue = property.Key.GetValue(exception);
if (propertyValue != null)
{
jObject.AddFirst(new Newtonsoft.Json.Linq.JProperty(resolver.GetResolvedPropertyName(property.Value),
Newtonsoft.Json.Linq.JToken.FromObject(propertyValue, serializer)));
}
}
value = jObject;
}
serializer.Serialize(writer, value);
}
public async Task <bool> TriggerBuzzer()
{
HttpClient httpClient = new HttpClient();
Newtonsoft.Json.JsonSerializer jser = new Newtonsoft.Json.JsonSerializer();
httpClient.BaseAddress = new Uri("https://ptnetsuite.a2asmartcity.io/");
System.IO.StringWriter stringWriter = new System.IO.StringWriter();
MqttMessage triggerBuzzerMex = new MqttMessage(1, 0);
jser.Serialize(stringWriter, triggerBuzzerMex);
StringContent authContent = new StringContent(stringWriter.ToString(), Encoding.UTF8, "application/json");
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", authToken.accessToken);
HttpResponseMessage resp = await httpClient.PostAsync($"/api/mqtt/v1/users/{username}/apps/{appid}/devices/{deveui}/downlink", authContent);
string respBody = await resp.Content.ReadAsStringAsync();
if (resp.IsSuccessStatusCode)
{
return(true);
}
else
{
return(false);
}
}
public static string SerializeToContent(object obj)
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Converters.Add(new Newtonsoft.Json.Converters.JavaScriptDateTimeConverter());
serializer.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
serializer.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto;
Stream objectStream;
using (objectStream = new MemoryStream())
{
using (StreamWriter writter = new StreamWriter(objectStream, Encoding))
{
using (Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(writter))
{
serializer.Serialize(writer, obj);
objectStream.Seek(0, SeekOrigin.Begin);
}
}
}
using (StreamReader sr = new StreamReader(objectStream))
{
return(sr.ReadToEnd());
}
}
public void GuardarJson(string A)
{
string path;
string pathJ;
path = @"~/App_Data/ " + A + ".txt";
pathJ = @"~/App_Data/ " + A + ".txt";
string root = @"~/App_Data/ ";
if (!Directory.Exists(root))
{
Directory.CreateDirectory(root);
}
if (!System.IO.File.Exists(path))
{
using (FileStream strm = System.IO.File.Create(path))
using (StreamWriter sw = new StreamWriter(strm))
{
sw.WriteLine("No_Info");
sw.Close();
}
}
using (StreamWriter file = System.IO.File.CreateText(@"C:\LAB3\" + A + ".txt"))
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Serialize(file, mostrar);
}
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
if (value is KeyValueObject)
{
serializer.Serialize(writer, value?.ToString());
}
}
public static void NewLocalData(string dataDirectory)
{
var file = new System.IO.DirectoryInfo(dataDirectory).GetFiles(PatchLauncher.DATAINFOFILENAME).FirstOrDefault();
DataInfo dataInfo = default;
if (file is null)
{
dataInfo = new DataInfo {
DataVersion = DefaultLocalDataVersion
};
}
else
{
using (var streamReader = new System.IO.StreamReader(file.FullName))
using (var jsonTxtReader = new Newtonsoft.Json.JsonTextReader(streamReader))
{
var jser = new Newtonsoft.Json.JsonSerializer();
dataInfo = jser.Deserialize <DataInfo>(jsonTxtReader);
dataInfo.DataVersion = DefaultLocalDataVersion;
}
file.Delete();
}
using (var stream = System.IO.File.OpenWrite(System.IO.Path.Combine(dataDirectory, PatchLauncher.DATAINFOFILENAME)))
using (var streamWriter = new System.IO.StreamWriter(stream))
using (var jsonTxtWriter = new Newtonsoft.Json.JsonTextWriter(streamWriter))
{
var jser = new Newtonsoft.Json.JsonSerializer();
jser.Serialize(jsonTxtWriter, dataInfo);
}
}
public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
{
var fi = value as FieldInfo;
var pi = value as PropertyInfo;
var details = new
{
Name =
fi != null ? fi.Name :
pi != null ? pi.Name :
null,
MemberType =
fi != null ? fi.FieldType :
pi != null ? pi.PropertyType :
null,
};
if (details.Name != null)
{
serializer.Serialize(writer, details);
}
else
{
writer.WriteNull();
}
}
public IHttpActionResult Get(string format = "yaml")
{
var stream = this.GetType().Assembly.GetManifestResourceStream("ConferenceWebApi.OpenApi2.yaml");
HttpContent responseContent;
if (format == "json" || this.Request.Headers.Accept.Contains(new MediaTypeWithQualityHeaderValue("application/json")))
{
var serializer = new Serializer(new SerializerSettings()
{
EmitJsonComptible = true
});
var yamlObject = serializer.Deserialize(stream);
var buffer = new StringBuilder();
var jserializer = new Newtonsoft.Json.JsonSerializer();
jserializer.Serialize(new StringWriter(buffer), yamlObject);
responseContent = new StringContent(buffer.ToString());
responseContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
}
else
{
responseContent = new StreamContent(stream);
responseContent.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
}
return(new OkResult(Request)
.WithContent(responseContent));
}
// convert string/file to YAML object
public static void Test()
{
using (System.IO.FileStream fs = System.IO.File.OpenRead(@"d:\username\Documents\Visual Studio 2017\Projects\BlueMine\BlueMine\Code\en.yml"))
{
//using (System.IO.TextReader r = new System.IO.StringReader(@""))
using (System.IO.TextReader r = new System.IO.StreamReader(fs, System.Text.Encoding.UTF8))
{
YamlDotNet.Serialization.Deserializer deserializer =
new YamlDotNet.Serialization.Deserializer();
object yamlObject = deserializer.Deserialize(r);
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Formatting = Newtonsoft.Json.Formatting.Indented;
// serializer.Serialize(Console.Out, yamlObject);
using (System.IO.Stream ws = System.IO.File.OpenWrite(@"d:\username\Documents\Visual Studio 2017\Projects\BlueMine\BlueMine\Code\en.json"))
{
using (System.IO.TextWriter sw = new System.IO.StreamWriter(ws, System.Text.Encoding.UTF8))
{
serializer.Serialize(sw, yamlObject);
} // End using sw
} // End Using ws
} // End Using r
} // End Using fr
} // End Sub Test
private string ConvertJsonString(string str)
{
//格式化json字符串
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
TextReader tr = new StringReader(str);
Newtonsoft.Json.JsonTextReader jtr = new Newtonsoft.Json.JsonTextReader(tr);
object obj = serializer.Deserialize(jtr);
if (obj != null)
{
StringWriter textWriter = new StringWriter();
Newtonsoft.Json.JsonTextWriter jsonWriter = new Newtonsoft.Json.JsonTextWriter(textWriter)
{
Formatting = Newtonsoft.Json.Formatting.Indented,
Indentation = 4,
IndentChar = ' '
};
serializer.Serialize(jsonWriter, obj);
return(textWriter.ToString());
}
else
{
return(str);
}
}
public void TestSerialization()
{
// Arrange.
Student expected = new Student("Vsevolod", Faculty.CS, 4);
// Act.
using (Newtonsoft.Json.JsonTextWriter fs = new Newtonsoft.Json.JsonTextWriter(new StreamWriter(JSON_TEST_FILE)))
{
Newtonsoft.Json.JsonSerializer jsonSerializer = new Newtonsoft.Json.JsonSerializer();
jsonSerializer.Serialize(fs, expected);
}
// Assert.
Student actual;
using (StreamReader file = File.OpenText(JSON_TEST_FILE))
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
actual = (Student)serializer.Deserialize(file, typeof(Student));
}
Assert.AreEqual(expected.Name, actual.Name, "Actual name is incorrect");
Assert.AreEqual(expected.Faculty, actual.Faculty, "Faculty is incorrect");
Assert.AreEqual(expected.Mark, actual.Mark, "Mark is incorrect");
}
/// <summary>
/// Saves an object to a json-file.
/// </summary>
public static bool SaveJsonFile(string filePath, object data, out string errorMessage, Newtonsoft.Json.JsonConverter converter = null)
{
if (string.IsNullOrEmpty(filePath))
{
errorMessage = "File path is empty.\nCouldn't be saved.";
return(false);
}
errorMessage = null;
try
{
using (StreamWriter sw = File.CreateText(filePath))
{
var ser = new Newtonsoft.Json.JsonSerializer();
if (converter != null)
{
ser.Converters.Add(converter);
}
ser.Serialize(sw, data);
}
return(true);
}
catch (SerializationException ex)
{
errorMessage = $"File\n{Path.GetFullPath(filePath)}\ncouldn't be saved.\nError message:\n\n" + ex.Message;
}
return(false);
}
static unsafe void GetBoth <T>(LowWriter <T> lw, T s, out IEnumerable <byte> newtonsoft, out IEnumerable <byte> unsafeJson, int?minBuffer = null)
{
var ms = new MemoryStream();
int len;
using (var writer = new StreamWriter(ms, _utf8))
{
_serializer.Serialize(writer, s, typeof(string));
writer.Flush();
len = (int)ms.Position;
}
newtonsoft = ms.GetBuffer().Take(len);
if (minBuffer.HasValue && minBuffer.Value > len)
{
len = minBuffer.Value;
}
var mine = new byte[len];
fixed(byte *bs = mine)
{
var result = lw.Invoke(s, bs, len);
unsafeJson = result < 0 ? null : mine.Take(result);
}
}
public void Serialize(System.IO.Stream stream, object obj)
{
using (var sw = new StreamWriter(stream, Encoding ?? System.Text.Encoding.UTF8))
{
serializer.Serialize(sw, obj);
}
}
public override void ExecuteResult(ControllerContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
HttpResponseBase response = context.HttpContext.Response;
if (string.IsNullOrEmpty(this.ContentType))
{
response.ContentType = this.ContentType;
}
else
{
response.ContentType = "application/json";
}
if (this.ContentEncoding != null)
{
response.ContentEncoding = this.ContentEncoding;
}
if (this.Data != null)
{
var Serializer = new Newtonsoft.Json.JsonSerializer();
Serializer.DateFormatString = "yyyy-MM-dd HH:mm:ss";
StringBuilder JsonStr = new StringBuilder();
Serializer.Serialize(new System.IO.StringWriter(JsonStr), this.Data);
response.Write(JsonStr);
}
}
public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result)
{
byte[] body;
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
using (MemoryStream ms = new MemoryStream())
{
using (StreamWriter sw = new StreamWriter(ms, Encoding.UTF8))
{
using (Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(sw))
{
writer.Formatting = Newtonsoft.Json.Formatting.Indented;
serializer.Serialize(writer, result);
sw.Flush();
body = ms.ToArray();
}
}
}
Message replyMessage = Message.CreateMessage(messageVersion, operation.Messages[1].Action, new RawBodyWriter(body));
replyMessage.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Raw));
HttpResponseMessageProperty respProp = new HttpResponseMessageProperty();
respProp.Headers[HttpResponseHeader.ContentType] = "application/json";
replyMessage.Properties.Add(HttpResponseMessageProperty.Name, respProp);
return(replyMessage);
}
/// <summary>
/// 格式化json输出
/// </summary>
/// <param name="jsonString"></param>
/// <returns></returns>
public static string FormatJson(this string jsonString)
{
try
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
StringReader sr = new StringReader(jsonString);
object obj = serializer.Deserialize(new Newtonsoft.Json.JsonTextReader(sr));
if (obj != null)
{
StringWriter sw = new StringWriter();
Newtonsoft.Json.JsonWriter jsonWriter = new Newtonsoft.Json.JsonTextWriter(sw)
{
Formatting = Newtonsoft.Json.Formatting.Indented,
Indentation = 4,
IndentChar = ' '
};
serializer.Serialize(jsonWriter, obj);
return(sw.ToString());
}
else
{
return(jsonString);
}
}
catch
{
return(jsonString);
}
}
public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result)
{
byte[] body;
var serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Converters.Add(new IsoDateTimeConverter()
{
DateTimeFormat = "yyyy-MM-ddTHH:mm:ssZ", DateTimeStyles = DateTimeStyles.AdjustToUniversal
});
using (var ms = new MemoryStream())
{
using (var sw = new StreamWriter(ms, Encoding.UTF8))
{
using (Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(sw))
{
//writer.Formatting = Newtonsoft.Json.Formatting.Indented;
serializer.Serialize(writer, result);
sw.Flush();
body = ms.ToArray();
}
}
}
var replyMessage = Message.CreateMessage(messageVersion, _operation.Messages[1].Action, new RawBodyWriter(body));
replyMessage.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Raw));
var respProp = new HttpResponseMessageProperty();
respProp.Headers[HttpResponseHeader.ContentType] = "application/json";
replyMessage.Properties.Add(HttpResponseMessageProperty.Name, respProp);
return(replyMessage);
}
/// <summary>返回格式化后json字符串</summary>
/// <param name="str">json字符串</param>
/// <param name="errs">发生错误则返回错误信息</param>
/// <returns>返回格式化后json字符串</returns>
public static string FormatJsonString(string str, ref string errs)
{
try
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
TextReader tr = new StringReader(str);
Newtonsoft.Json.JsonTextReader jtr = new Newtonsoft.Json.JsonTextReader(tr);
object obj = serializer.Deserialize(jtr);
if (obj != null)
{
StringWriter textWriter = new StringWriter();
Newtonsoft.Json.JsonTextWriter jsonWriter = new Newtonsoft.Json.JsonTextWriter(textWriter)
{
Formatting = Newtonsoft.Json.Formatting.Indented,
Indentation = 4,
IndentChar = ' '
};
serializer.Serialize(jsonWriter, obj);
return(textWriter.ToString());
}
}
catch (Exception ex)
{
errs = "格式化json失败，错误信息：" + ex.Message;
}
return(str);
}
public string SerializeJsonNet(object value)
{
Type type = value.GetType();
Newtonsoft.Json.JsonSerializer json = new Newtonsoft.Json.JsonSerializer();
json.NullValueHandling = NullValueHandling.Ignore;
json.ObjectCreationHandling = Newtonsoft.Json.ObjectCreationHandling.Replace;
json.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore;
json.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
StringWriter sw = new StringWriter();
Newtonsoft.Json.JsonTextWriter writer = new JsonTextWriter(sw);
writer.Formatting = Formatting.None;
writer.QuoteChar = '"';
json.Serialize(writer, value);
string output = sw.ToString();
writer.Close();
return(output);
}
private void SaveArchiveLastCommit(string destination, string filename, string hash)
{
var path = Path.Combine(destination, filename);
var jsonPath = path + ".json";
if (File.Exists(path))
{
try
{
Log.Verbose("Checking last commit hash in archive json file {0}", jsonPath);
using (var textReader = new StreamWriter(jsonPath, false))
using (var jsonReader = new Newtonsoft.Json.JsonTextWriter(textReader))
{
var serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Serialize(jsonReader, new ArchiveInfo()
{
LastCommit = hash
});
}
}
catch (Exception ex)
{
Log.Error(ex, "GetArchiveLastCommit:: unable to write last commit hash to json file");
}
}
else
{
Log.Warning("Archive file {0} is missing", path);
}
}
/// <summary>
/// Serialize the object into a byte array
/// </summary>
/// <param name="obj">Object to serialize</param>
/// <returns>Byte array to send in the request body</returns>
public byte[] Serialize(object obj)
{
var serializer = new Newtonsoft.Json.JsonSerializer();
ConfigureSerializer(serializer);
var output = new System.IO.MemoryStream();
using (var writer = new System.IO.StreamWriter(output))
serializer.Serialize(writer, obj);
return output.ToArray();
}
public Message SerializeRequest(MessageVersion messageVersion, object[] parameters)
{
byte[] body;
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
using (MemoryStream ms = new MemoryStream())
{
using (StreamWriter sw = new StreamWriter(ms, Encoding.UTF8))
{
using (Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(sw))
{
writer.Formatting = Newtonsoft.Json.Formatting.Indented;
if (parameters.Length == 1)
{
// Single parameter, assuming bare
serializer.Serialize(sw, parameters[0]);
}
else
{
writer.WriteStartObject();
for (int i = 0; i < this.operation.Messages[0].Body.Parts.Count; i++)
{
writer.WritePropertyName(this.operation.Messages[0].Body.Parts[i].Name);
serializer.Serialize(writer, parameters[0]);
}
writer.WriteEndObject();
}
writer.Flush();
sw.Flush();
body = ms.ToArray();
}
}
}
Message requestMessage = Message.CreateMessage(messageVersion, operation.Messages[0].Action, new RawBodyWriter(body));
requestMessage.Headers.To = operationUri;
requestMessage.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Raw));
HttpRequestMessageProperty reqProp = new HttpRequestMessageProperty();
reqProp.Headers[HttpRequestHeader.ContentType] = "application/json";
requestMessage.Properties.Add(HttpRequestMessageProperty.Name, reqProp);
return requestMessage;
}
public void ProcessRequest(System.Web.HttpContext context)
{
context.Response.ContentType = "application/json";
Newtonsoft.Json.JsonTextWriter jsonWriter = new Newtonsoft.Json.JsonTextWriter(context.Response.Output);
Newtonsoft.Json.JsonSerializer ser = new Newtonsoft.Json.JsonSerializer();
using (System.Data.DataTable dt = Basic_SQL.SQL.GetDataTable("SELECT COL_Hex FROM T_SYS_ApertureColorToHex ORDER BY COL_Aperture"))
{
jsonWriter.Formatting = Newtonsoft.Json.Formatting.Indented;
ser.Serialize(jsonWriter, dt);
jsonWriter.Flush();
} // End Using dt
}
/// <summary>
/// Stream an IObject to JSON
/// </summary>
/// <param name="stream">the stream to serialize the object to</param>
/// <param name="o">the oject to be serialized</param>
public void Stream( System.IO.StreamWriter stream, IObject o )
{
try
{
Newtonsoft.Json.JsonWriter jw = new Newtonsoft.Json.JsonTextWriter(stream);
jw.Formatting = Newtonsoft.Json.Formatting.Indented;
var js = new Newtonsoft.Json.JsonSerializer();
js.Serialize(jw, o);
}
catch (Exception)
{
throw new NotImplementedException("Method Stream not yet implemented for objects like \"" + o.Name + "\" of class \"SimpleObject\"");
}
}
public virtual void Write(Entry e, int deep)
{
writer.WriteLine();
for (int i = 0; i < deep; ++i)
writer.Write("\t");
var str = new StringWriter();
var jsonSer = new Newtonsoft.Json.JsonSerializer();
jsonSer.Serialize(str, e.Properties);
writer.WriteLine("{{ description: '{0}', offset: {1:0.000}, duration: {2:0.000}, severity: {3}, properties: {4}, entries: [", e.Description, e.Offset, e.Duration, e.Severity, str.ToString());
foreach (Entry s in e.Entries)
{
Write(s, deep + 1);
}
writer.WriteLine("]}}");
}
protected override void Send(ManagementReport report, String activityId, String agentId)
{
var reportJson = new Dictionary<String, Object>{
{"ID", report.ID},
{"SourceID", report.SourceID },
{"DateTime", report.DateTime},
{"State", new Dictionary<String, Object> {
{"Health", report.State.Health.ToString() },
{"Execution", report.State.Execution.ToString()},
{"Failures", (from f in report.State.Failures
select new Dictionary<String, Object> {
{"FailureID", f.FailureID},
{"SourceID", f.SourceID},
{"Details", f.Details}
}).ToArray()}
}},
{"Metrics", report.Metrics != null ? (from m in report.Metrics
select new Dictionary<String, Object> {
{"MetricID", m.MetricID},
{"SourceID", m.SourceID},
{"Reference", m.Reference},
{"Value", m.Value},
{"Details", m.Details},
{"CategoryID", m.CategoryID},
{"DateTime", m.DateTime }
}).ToArray() : null},
{"ActivityID", activityId},
{"AgentID", agentId},
};
var str = new StringWriter();
var jsonSer = new Newtonsoft.Json.JsonSerializer();
jsonSer.Serialize(str, reportJson);
NetBrokerMessage brokerMessage = new NetBrokerMessage(str.ToString());
this.brokerClient.Publish(brokerMessage, this.topic);
}
public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result)
{
byte[] body;
var serializer = new Newtonsoft.Json.JsonSerializer();
using (var ms = new MemoryStream())
{
using (var sw = new StreamWriter(ms, Encoding.UTF8))
{
using (Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(sw))
{
//writer.Formatting = Newtonsoft.Json.Formatting.Indented;
serializer.Serialize(writer, result);
sw.Flush();
body = ms.ToArray();
}
}
}
var replyMessage = Message.CreateMessage(messageVersion, _operation.Messages[1].Action, new RawBodyWriter(body));
replyMessage.Properties.Add(WebBodyFormatMessageProperty.Name, new WebBodyFormatMessageProperty(WebContentFormat.Raw));
var respProp = new HttpResponseMessageProperty();
respProp.Headers[HttpResponseHeader.ContentType] = "application/json";
replyMessage.Properties.Add(HttpResponseMessageProperty.Name, respProp);
return replyMessage;
}
public static void WriteJsonUsingNewtonsoftSerializer(object obj, TextWriter writer)
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Serialize(writer, obj);
}
private void SaveData(object sender, EventArgs e)
{
try
{
if (!System.IO.Directory.Exists(
Application.StartupPath + "/_DarkestQuirksBackup/"))
{
System.IO.Directory.CreateDirectory(
Application.StartupPath + "/_DarkestQuirksBackup/");
}
if (!System.IO.File.Exists(
Application.StartupPath + "/_DarkestQuirksBackup/quirk_library.json"))
{
System.IO.File.Move(Application.StartupPath + "/shared/quirk/quirk_library.json",
Application.StartupPath + "/_DarkestQuirksBackup/quirk_library.json");
}
else goto BACKUPS_EXIST;
if (!System.IO.File.Exists(
Application.StartupPath + "/_DarkestQuirksBackup/quirks.string_table.xml"))
{
System.IO.File.Move(Application.StartupPath + "/localization/quirks.string_table.xml",
Application.StartupPath + "/_DarkestQuirksBackup/quirks.string_table.xml");
}
else goto BACKUPS_EXIST;
if (!System.IO.File.Exists(
Application.StartupPath + "/_DarkestQuirksBackup/dialogue.string_table.xml"))
{
System.IO.File.Move(Application.StartupPath + "/localization/dialogue.string_table.xml",
Application.StartupPath + "/_DarkestQuirksBackup/dialogue.string_table.xml");
}
BACKUPS_EXIST:
using (System.IO.FileStream fs = System.IO.File.OpenWrite(
Application.StartupPath + "/shared/quirk/quirk_library.json"))
using (System.IO.StreamWriter sw =
new System.IO.StreamWriter(fs))
using (Newtonsoft.Json.JsonWriter jw =
new Newtonsoft.Json.JsonTextWriter(sw))
{
jw.Formatting = Newtonsoft.Json.Formatting.Indented;
Newtonsoft.Json.JsonSerializer js = new Newtonsoft.Json.JsonSerializer();
quirk_data.quirks = quirks.ToArray();
js.Serialize(jw, quirk_data);
jw.Close();
}
descriptions.Save(
Application.StartupPath + "/localization/quirks.string_table.xml");
dialogue.Save(
Application.StartupPath + "/localization/dialogue.string_table.xml");
MessageBox.Show("Modifications saved");
}
catch //(Exception ex)
{
//System.Diagnostics.Debug.WriteLine(ex);
}
}
// Code to execute when the application is closing (eg, user hit Back)
// This code will not execute when the application is deactivated
private void Application_Closing(object sender, ClosingEventArgs e)
{
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
using (var stream = new IsolatedStorageFileStream("data.txt",
FileMode.Create,
FileAccess.Write,
store))
using (var writer = new StreamWriter(stream))
{
var serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Serialize(writer, ViewModel);
}
}
/// <summary>
/// Creates a temporary verification file.
/// </summary>
/// <returns>The verification file.</returns>
/// <param name="db">The database instance</param>
/// <param name="stream">The stream to write to</param>
public static void CreateVerificationFile(LocalDatabase db, System.IO.StreamWriter stream)
{
var s = new Newtonsoft.Json.JsonSerializer();
s.Serialize(stream, db.GetRemoteVolumes().Cast<IRemoteVolume>().ToArray());
}
private bool _SyncToDisk(Item item, List<Item> children)
{
try
{
if (_cancelProcessing)
{
return false;
}
if (String.IsNullOrEmpty(RootFolderId))
{
Log.Error("Cannot sync Journal to disk - RootFolderId is blank.");
return false;
}
MutexSyncToDisk.Wait();
try
{
_UpdateProcessCount("_SyncToDisk", 1);
_syncingToDisk = true;
try
{
if (_lastSyncedRootFolderId == null || _lastSyncedRootFolderId != RootFolderId)
{
System.IO.File.WriteAllText(Settings.RootIdFilePath, RootFolderId);
_lastSyncedRootFolderId = RootFolderId;
}
if (_lastLargestChangeId == null || _lastLargestChangeId != RootFolderId)
{
System.IO.File.WriteAllText(Settings.LastChangeIdPath, LargestChangeId.ToString());
_lastSyncedRootFolderId = RootFolderId;
}
string journalFilePath = Settings.GetJournalFilePath(item.File.Id + ".item");
using (
System.IO.FileStream fileStream = OpenFile(journalFilePath,
System.IO.FileMode.Create,
System.IO.FileAccess.Write,
System.IO.FileShare.Write))
{
using (var streamWriter = new System.IO.StreamWriter(fileStream))
{
using (Newtonsoft.Json.JsonWriter jsonWriter = new Newtonsoft.Json.JsonTextWriter(streamWriter))
{
jsonWriter.Formatting = Newtonsoft.Json.Formatting.None;
var jsonSerializer = new Newtonsoft.Json.JsonSerializer();
jsonSerializer.Serialize(jsonWriter, item);
}
}
}
System.IO.File.SetCreationTime(journalFilePath, DateTime.Now);
journalFilePath = Settings.GetJournalFilePath(item.File.Id + ".children");
using (
System.IO.FileStream fileStream = OpenFile(journalFilePath,
System.IO.FileMode.Create,
System.IO.FileAccess.Write,
System.IO.FileShare.Write))
{
using (var streamWriter = new System.IO.StreamWriter(fileStream))
{
using (Newtonsoft.Json.JsonWriter jsonWriter = new Newtonsoft.Json.JsonTextWriter(streamWriter))
{
jsonWriter.Formatting = Newtonsoft.Json.Formatting.None;
var jsonSerializer = new Newtonsoft.Json.JsonSerializer();
jsonSerializer.Serialize(jsonWriter, children);
}
}
}
System.IO.File.SetCreationTime(journalFilePath, DateTime.Now);
}
finally
{
_syncingToDisk = false;
_UpdateProcessCount("_SyncToDisk", -1);
}
}
finally
{
MutexSyncToDisk.Release();
}
return true;
}
catch (Exception exception)
{
Log.Error(exception, false);
return false;
}
}
public void NewtonsoftJsonSerialize()
{
var serializer = new Newtonsoft.Json.JsonSerializer() {
DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
};
var writer = new StringWriter();
serializer.Serialize(writer, ComplexMessage);
Console.WriteLine(writer.ToString());
}
public void NewtonsoftJsonSerializeDeserializeBenchmark()
{
var serializer = new Newtonsoft.Json.JsonSerializer() {
DefaultValueHandling = Newtonsoft.Json.DefaultValueHandling.Ignore,
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
};
int runs = 50000;
DateTime start, stop;
MessageModel msg = null;
start = DateTime.UtcNow;
for (int i = 0; i < runs; i++) {
var writer = new StringWriter();
serializer.Serialize(writer, SimpleMessage);
var reader = new StringReader(writer.ToString());
var jsonReader = new Newtonsoft.Json.JsonTextReader(reader);
var dtoMsg = serializer.Deserialize<MessageDtoModelV1>(jsonReader);
}
stop = DateTime.UtcNow;
Assert.AreEqual(ComplexMessage, msg);
var total = (stop - start).TotalMilliseconds;
Console.WriteLine(
"NewtonsoftJsonSerialize+Deserialize(Simple): avg: {0:0.00} ms runs: {1} took: {2:0.00} ms",
total / runs,
runs,
total
);
start = DateTime.UtcNow;
for (int i = 0; i < runs; i++) {
var writer = new StringWriter();
serializer.Serialize(writer, ComplexMessage);
var reader = new StringReader(writer.ToString());
var jsonReader = new Newtonsoft.Json.JsonTextReader(reader);
var dtoMsg = serializer.Deserialize<MessageDtoModelV1>(jsonReader);
}
stop = DateTime.UtcNow;
Assert.AreEqual(ComplexMessage, msg);
total = (stop - start).TotalMilliseconds;
Console.WriteLine(
"NewtonsoftJsonSerialize+Deserialize(ComplexMessage): avg: {0:0.00} ms runs: {1} took: {2:0.00} ms",
total / runs,
runs,
total
);
}
private void SerializeJsonNetBinaryBenchInner(object o, MemoryStream ms)
{
for (int i = 0; i < Iterations; i++)
{
var s = new Newtonsoft.Json.JsonSerializer();
var w = new BsonWriter(ms);
s.Serialize(w, o);
Escape(w);
w.Flush();
}
}
public string ToBson()
{
StringBuilder sb = new StringBuilder();
System.IO.StringWriter sWriter = new System.IO.StringWriter(sb);
Newtonsoft.Json.JsonWriter writer = new Newtonsoft.Json.JsonTextWriter(sWriter);
Newtonsoft.Json.JsonSerializer jSerial = new Newtonsoft.Json.JsonSerializer();
writer.Formatting = Newtonsoft.Json.Formatting.None;
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer {
NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore,
ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore,
ContractResolver = new Misc.BSONResolver(),
};
serializer.Serialize(writer, this);
writer.Close();
sWriter.Close();
return sb.ToString();
}
private static void SerializeJsonNet(int count)
{
var s2 = new Newtonsoft.Json.JsonSerializer();
var m = new MemoryStream(8000);
for (int i = 0; i < count; i++)
{
var t = new StreamWriter(m);
s2.Serialize(t, testData);
t.Flush();
m.Position = 0;
}
}
private string Serialize(object body)
{
var jsonSerializer = new Newtonsoft.Json.JsonSerializer();
var sb = new StringBuilder();
using (var textWriter = new System.IO.StringWriter(sb))
{
using (var jsonWriter = new Newtonsoft.Json.JsonTextWriter(textWriter))
{
jsonSerializer.Serialize(jsonWriter, body);
}
}
var result = sb.ToString();
return result;
}
private void saveAsToolStripMenuItem_Click(object sender, EventArgs e)
{
SaveFileDialog sfd1 = new SaveFileDialog();
sfd1.Title = "Save DataSource";
sfd1.Filter = "StatBot DataSource (*.statds)|*.statds";
sfd1.DefaultExt = ".statdt";
sfd1.InitialDirectory = Instance.study.StatBotFileLocation;
if (sfd1.ShowDialog() == DialogResult.OK)
{
using (StreamWriter file = File.CreateText(sfd1.FileName))
{
Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Serialize(file, bindingSource1.DataSource);
}
}
}