/// <summary>
/// Serialize objects to a byte array synchronously, using user defined logic.
/// </summary>
/// <param name="serialization_callback">The callback used to serialize the data once the context is set.</param>
/// <param name="default_buffer_size">The default size to use for serialization buffer.</param>
/// <returns>The serialized data.</returns>
public byte[] Serialize(SerializationCallback serialization_callback, uint default_buffer_size = defaultSerializationBufferSize)
{
byte[] result = null;
Buffer buffer = null;
try
{
buffer = GetBuffer(default_buffer_size);
uint written = serialization_callback(this, ref buffer);
result = new byte[written];
Array.Copy(buffer.Data, result, written);
}
catch (Exception e)
{
throw new SerializationException("An error occured during serialization.", e);
}
finally
{
if (buffer != null)
{
buffer.Dispose();
}
}
return(result);
}
/// <summary>
/// Serialize an object to a byte array asynchronously, using user defined logic.
/// </summary>
/// <param name="serialization_callback">The callback used to serialize the data once the context is set.</param>
/// <param name="callback">A callback called once the data is serialized to get the result byte array and serialized size.</param>
/// <param name="progress">A callback to get progress notifications.</param>
/// <param name="default_buffer_size">The default size to use for serialization buffer.</param>
/// <returns>An enumerator to wait for the serialization completion.</returns>
public IEnumerator Serialize(SerializationCallback serialization_callback, Action <Buffer> callback, Action <float> progress = null, uint default_buffer_size = defaultSerializationBufferSize)
{
Buffer buffer = null;
DateTime time = DateTime.Now + progressRefresRate;
float progress_percentage = 0f;
buffer = GetBuffer(default_buffer_size, p => progress_percentage = p);
Task <uint> result = Task.Run(() => serialization_callback(this, ref buffer));
while (!result.IsCompleted)
{
if (progress != null && DateTime.Now >= time)
{
progress(progress_percentage);
time = DateTime.Now + progressRefresRate;
}
yield return(null);
}
if (result.Exception != null)
{
throw new SerializationException("An error occured during serialization.", result.Exception);
}
buffer.Size = result.Result;
callback?.Invoke(buffer);
}
/// <summary>
/// 移除一个序列化/反序列化事件的回调
/// </summary>
/// <typeparam name="T">序列化/反序列化对象的类型</typeparam>
/// <param name="type">回调的类型</param>
/// <param name="callback">回调委托</param>
public static void RemoveCallback <T>(SerializationCallbackType type, SerializationCallback <T> callback)
{
if (type == SerializationCallbackType.OnBeforeSerialization)
{
InternalTypeCache <T> .OnBeforeSerializationCallbacks -= callback;
}
else
{
InternalTypeCache <T> .OnAfterDeserializationCallbacks -= callback;
}
}
/// <summary>
/// Serialize objects to a buffer synchronously, using user defined logic.
/// </summary>
/// <remarks>Serialized data size is store in buffer Size property. Returned buffer must be disposed after use.</remarks>
/// <param name="serialization_callback">The callback used to serialize the data once the context is set.</param>
/// <param name="default_buffer_size">The default size to use for serialization buffer.</param>
/// <returns>The serialized data.</returns>
public Buffer Serialize(SerializationCallback serialization_callback, uint default_buffer_size = defaultSerializationBufferSize)
{
Buffer buffer = null;
try
{
buffer = GetBuffer(default_buffer_size);
buffer.Size = serialization_callback(this, ref buffer);
}
catch (Exception e)
{
throw new SerializationException("An error occured during serialization.", e);
}
return(buffer);
}
public ShouldSerializeContractResolver(Predicate <object> shouldSerialize)
: base()
{
this.shouldSerialize = shouldSerialize;
this.serializationCallback = (o, context) =>
{
if (shouldSerialize != null && !this.shouldSerialize(o))
{
throw new JsonSkipObjectException();
}
};
this.onErrorCallback = (o, context, errorContext) =>
{
if (errorContext.Error is JsonSkipObjectException)
{
errorContext.Handled = true;
}
};
}
protected ISupportInitializeContractResolver()
: base()
{
onDeserializing = (o, context) =>
{
var init = o as ISupportInitialize;
if (init != null)
{
init.BeginInit();
}
};
onDeserialized = (o, context) =>
{
var init = o as ISupportInitialize;
if (init != null)
{
init.EndInit();
}
};
}
/// <summary>
/// Serialize an object to a file asynchronously, using user defined logic.
/// </summary>
/// <param name="serialization_callback">The callback used to serialize the data once the context is set.</param>
/// <param name="filename">The name of the file where to save the serialized data.</param>
/// <param name="callback">A callback called once the data is serialized to know if the serialization was a success.</param>
/// <param name="progress">A callback to get progress notifications.</param>
/// <param name="default_buffer_size">The default size to use for serialization buffer.</param>
/// <returns>An enumerator to wait for the serialization completion.</returns>
public IEnumerator Serialize(SerializationCallback serialization_callback, string filename, Action <bool> callback = null, Action <float> progress = null, uint default_buffer_size = defaultSerializationBufferSize)
{
return(Serialize(serialization_callback, (b, s) =>
{
bool success = false;
if (b != null && b.Length > 0)
{
using (System.IO.FileStream fs = System.IO.File.Open(filename, System.IO.FileMode.Create, System.IO.FileAccess.Write, System.IO.FileShare.None))
{
fs.Write(b, 0, (int)s);
}
success = true;
}
if (callback != null)
{
callback(success);
}
}, progress, default_buffer_size));
}
/// <summary>
/// Serialize an object to a file asynchronously, using user defined logic.
/// </summary>
/// <param name="serialization_callback">The callback used to serialize the data once the context is set.</param>
/// <param name="filename">The name of the file where to save the serialized data.</param>
/// <param name="callback">A callback called once the data is serialized to know if the serialization was a success.</param>
/// <param name="progress">A callback to get progress notifications.</param>
/// <param name="default_buffer_size">The default size to use for serialization buffer.</param>
/// <returns>An enumerator to wait for the serialization completion.</returns>
public IEnumerator Serialize(SerializationCallback serialization_callback, string filename, Action <bool> callback = null, Action <float> progress = null, uint default_buffer_size = defaultSerializationBufferSize)
{
return(Serialize(serialization_callback, b => WriteToFile(b, filename, callback), progress, default_buffer_size));
}
/// <summary>
/// 移除序列化和反序列化事件的回调
/// </summary>
/// <typeparam name="T">序列化/反序列化对象的类型</typeparam>
/// <param name="onBeforeSerialization">在序列化前调用的回调</param>
/// <param name="onAfterDeserialization">在反序列化后调用的回调</param>
public static void RemoveCallback <T>(SerializationCallback <T> onBeforeSerialization, SerializationCallback <T> onAfterDeserialization)
{
InternalTypeCache <T> .OnBeforeSerializationCallbacks -= onBeforeSerialization;
InternalTypeCache <T> .OnAfterDeserializationCallbacks -= onAfterDeserialization;
}
