public static Dictionary <string, object> ToJson(this IJsonSerializable serializable)
{
var json = new Dictionary <string, object>();
serializable.Serialize(json);
return(json);
}
public void WriteProperty(string name, IJsonSerializable value)
{
if (value != null)
{
value.Serialize(this);
}
}
public static string ToJson(this IJsonSerializable serializable)
{
return(JsonConvert.SerializeObject(serializable, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}));
}
public static string ToJsonString(this IJsonSerializable jsonSerializable)
{
if (ReferenceEquals(jsonSerializable, null))
{
return(string.Empty);
}
var stringBuilder = new StringBuilder();
using (var writer = JSON.GetWriter(new StringWriter(stringBuilder)))
{
try
{
jsonSerializable.ToJson(writer);
}
catch (Exception ex)
{
if (Log != null)
{
Log.WarnFormat(
"Unable to serialize component: {0} - {1}",
jsonSerializable.GetType().Name,
ex.Message
);
}
throw;
}
}
return(stringBuilder.ToString());
}
public static string Serialize(IJsonSerializable obj)
{
Dictionary <string, object> data = new Dictionary <string, object> ();
obj.GetObjectData(data);
return(MiniJSON.Serialize(data));
}
public void WriteProperty(string name, IJsonSerializable value)
{
if (!this.IsNullOrEmpty(value))
{
this.WritePropertyName(name);
value.Serialize(this);
}
}
public static void WriteSerializable(
this Utf8JsonWriter writer,
string propertyName,
IJsonSerializable value)
{
writer.WritePropertyName(propertyName);
writer.WriteSerializableValue(value);
}
public static void WriteToFile(this IJsonSerializable serializable, string filePath, IDiagnosticLogger?logger)
{
using var file = File.Create(filePath);
using var writer = new Utf8JsonWriter(file);
serializable.WriteTo(writer, logger);
writer.Flush();
}
public void WriteObject(IJsonSerializable @object, JsonWriterOptions options = default)
{
using Utf8JsonWriter writer = CreateWriter(options);
writer.WriteStartObject();
@object.WriteProperties(writer);
writer.WriteEndObject();
}
public static TRes PackMessage <TRes>(string key, IJsonSerializable obj) where TRes : IDictionary <string, object>
{
var result = Activator.CreateInstance <TRes>();
result.Add(key, obj.ToJson());
return(result);
}
protected virtual void WriteValue(IJsonSerializable obj)
{
string json = obj.ToJson();
Debug.Assert(json != null);
this.WriteCore(json, false);
}
public void AddJNode(String propName, IJsonSerializable item)
{
if (item == null)
{
return;
}
var jn = item.ToJNode(null);
AddRaw(propName, jn._jo);
}
public static string ToJsonString(this IJsonSerializable serializable)
{
using var stream = new MemoryStream();
using var writer = new Utf8JsonWriter(stream);
writer.WriteSerializableValue(serializable);
writer.Flush();
return(Encoding.UTF8.GetString(stream.ToArray()));
}
void WriteJsonAttribute(IJsonSerializable serializable)
{
if (serializable != null)
{
string json = SymbolUtils.GetJsonForSymbol(serializable);
if (!string.IsNullOrEmpty(json))
writer.WriteElementString(Constants.esriMappingPrefix, "SymbolExtensions.Json",
Constants.esriMappingNamespace, json);
}
}
public static void SerializeToJson(IJsonSerializable data, string path)
{
using (FileStream fileStream = new FileStream(path, 2))
{
using (StreamWriter streamWriter = new StreamWriter(fileStream))
{
streamWriter.Write(data.ToJson());
}
}
}
public static string ToJson(this IJsonSerializable self)
{
JsonSerializerSettings settings = new JsonSerializerSettings()
{
TypeNameHandling = TypeNameHandling.Auto
};
var json = JsonConvert.SerializeObject(self, settings);
return(json);
}
public static void Deserialize(string json, IJsonSerializable obj)
{
if (string.IsNullOrEmpty(json))
{
return;
}
Dictionary <string, object> data = MiniJSON.Deserialize(json) as Dictionary <string, object>;
obj.SetObjectData(data);
}
public static string ToJsonString(this IJsonSerializable serializable)
{
using var stream = new MemoryStream();
using var writer = new Utf8JsonWriter(stream);
writer.WriteSerializableValue(serializable, new TraceDiagnosticLogger(SentryLevel.Debug));
writer.Flush();
return(Encoding.UTF8.GetString(stream.ToArray()));
}
public static string GetJsonForSymbol(IJsonSerializable serializable)
{
if (serializable == null)
{
return(null);
}
string json = serializable.ToJson();
return(json);
}
protected bool IsNullOrEmpty(IJsonSerializable instance)
{
if (instance != null)
{
emptyObjectDetector.IsEmpty = true;
instance.Serialize(emptyObjectDetector);
return(emptyObjectDetector.IsEmpty);
}
return(true);
}
public static E <string> FromJson(this IJsonSerializable jsonConfig, string json)
{
if (jsonConfig.ExpectsString)
{
json = JsonConvert.SerializeObject(json);
}
using var sr = new StringReader(json);
using var reader = new JsonTextReader(sr);
return(jsonConfig.FromJson(reader));
}
public static string ToJson(this IJsonSerializable jsonConfig)
{
var sb = new StringBuilder();
var sw = new StringWriter(sb);
using (var writer = new JsonTextWriter(sw))
{
writer.Formatting = Formatting.Indented;
jsonConfig.ToJson(writer);
}
return(sb.ToString());
}
public static void Serialize(this IJsonSerializable serializable, Dictionary <string, object> json)
{
if (serializable == null)
{
return;
}
serializable.GetType().GetJsonSerializedFields().ForEach(f => {
json.AddOrSet(f.Name, SerializeValue(f.GetValue(serializable)));
});
if (serializable is IJsonSerializableCustom)
{
((IJsonSerializableCustom)serializable).SerializeCustom(json);
}
}
/// <summary>
/// Deserializes a IJsonSerializable from json
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="json"></param>
public static void Deserialize <T>(this IJsonSerializable obj, string json)
{
if (obj is SerializableList <T> )
{
DeserializeSerializableList((SerializableList <T>)obj, json);
}
if (obj is SerializableDictionary <T> )
{
DeserializeSerializableDict((SerializableDictionary <T>)obj, json);
}
else
{
DeserializeObject(obj, json);
}
}
public void Pair(string name,
IJsonSerializable value)
{
if (null == value)
{
NullPair(name);
return;
}
_writer.Write("{0}\"{1}\":".FormatWith(Punctuation, name));
Nesting.Peek().Previous = JsonNodeType.None;
Object();
value.WriteJson(this);
EndObject();
}
/// <summary>
/// Creates the json request.
/// </summary>
/// <returns></returns>
internal JsonObject CreateJsonRequest()
{
IJsonSerializable serializableRequest = this as IJsonSerializable;
if (serializableRequest == null)
{
throw new JsonSerializationNotImplementedException();
}
JsonObject jsonRequest = new JsonObject();
jsonRequest.Add("Header", this.CreateJsonHeaders());
jsonRequest.Add("Body", serializableRequest.ToJson(service));
return(jsonRequest);
}
public static ReadOnlyMemory <byte> Serialize(this IJsonSerializable obj)
{
var writer = new ArrayBufferWriter <byte>();
using (var json = new Utf8JsonWriter(writer))
{
json.WriteStartObject();
obj.WriteProperties(json);
json.WriteEndObject();
json.Flush();
}
return(writer.WrittenMemory);
}
public static Stream ToStream(this IJsonSerializable obj)
{
var stream = new MemoryStream();
using (var json = new Utf8JsonWriter(stream))
{
json.WriteStartObject();
obj.WriteProperties(json);
json.WriteEndObject();
json.Flush();
}
stream.Seek(0, SeekOrigin.Begin);
return(stream);
}
public static void WriteJson(this IJsonSerializable obj, JsonTextWriter writer)
{
writer.WriteStartObject();
var polymorph = obj as IPolymorphable;
if (polymorph != null)
{
writer.WritePropertyName("classId");
writer.WriteValue(polymorph.GetClassId());
// var f = writer.Formatting;
// writer.Formatting = Formatting.None;
// writer.WritePropertyName("className");
// writer.WriteValue(obj.GetType().Name);
// writer.Formatting = f;
}
obj.WriteJsonFields(writer);
writer.WriteEndObject();
}
public static JsonArray FromArray <T>(T[] array)
{
int count = array.Length;
JsonArray result = new JsonArray(count);
bool serialize = typeof(IJsonSerializable).IsAssignableFrom(typeof(T));
for (int i = 0; i < count; i++)
{
if (serialize)
{
IJsonSerializable srz = (IJsonSerializable)array[i];
result._list.Add(srz.ToJson());
}
else
{
result._list.Add(array[i]);
}
}
return(result);
}
public void WriteValue(IJsonSerializable value)
{
if (value == null)
{
WriteCore("null", /* quotes */ false);
}
else
{
WriteCore(value.Serialize(this.minimizeWhitespace), /* quotes */ false);
}
}
protected virtual void WriteValue(IJsonSerializable obj)
{
string json = obj.ToJson();
Debug.Assert(json != null);
this.WriteCore(json, false);
}
public void WriteProperty(string name, IJsonSerializable value)
{
if (value != null)
{
value.Serialize(this);
}
}
protected bool IsNullOrEmpty(IJsonSerializable instance)
{
if (instance != null)
{
this.emptyObjectDetector.IsEmpty = true;
instance.Serialize(this.emptyObjectDetector);
return this.emptyObjectDetector.IsEmpty;
}
else
{
return true;
}
}
public void WriteProperty(string name, IJsonSerializable value)
{
if (!this.IsNullOrEmpty(value))
{
this.WritePropertyName(name);
value.Serialize(this);
}
}
public void Pair(string name,
IJsonSerializable value)
{
if (null == value)
{
NullPair(name);
return;
}
_writer.Write("{0}\"{1}\":".FormatWith(Punctuation, name));
Nesting.Peek().Previous = JsonNodeType.None;
Object();
value.WriteJson(this);
EndObject();
}
public static string GetJsonForSymbol(IJsonSerializable serializable)
{
if (serializable == null)
return null;
string json = serializable.ToJson();
return json;
}
public void Write(IJsonSerializable serializable)
{
Write(serializable.JsonSerialize());
}
public new bool IsNullOrEmpty(IJsonSerializable instance)
{
return base.IsNullOrEmpty(instance);
}
public void OnObjectForSaveInstantiated(IJsonSerializable jsonObject)
{
switch (jsonObject.JsonType)
{
case JsonObjectType.Map:
map = (GameMap)jsonObject;
break;
case JsonObjectType.Player:
player = (Player)jsonObject;
break;
case JsonObjectType.NPC:
npcList.Add((NonPlayerController)jsonObject);
break;
}
}
