private IBinarySerializable SerializeAndDeserializeObject(IBinarySerializable obj, Type objType)
{
dynamic buffer;
using (var stream = new MemoryStream())
{
var binaryWriter = new BinaryWriter(stream);
obj.Write(binaryWriter);
buffer = stream.ToArray();
}
var returnObj = Activator.CreateInstance(objType) as IBinarySerializable;
using (var readStream = new MemoryStream(buffer))
{
var binaryReader = new BinaryReader(readStream);
returnObj.Read(binaryReader);
}
return(returnObj);
}
/// <summary>
/// Serialize a IBinarySerializable object.
/// </summary>
/// <param name="buffer">The buffer where to serialize the data.</param>
/// <param name="start">The start index in the buffer where to serialize the data.</param>
/// <param name="value">The object to serialize.</param>
/// <returns>The number of serialized bytes.</returns>
public uint ToBytes(ref Buffer buffer, uint start, IBinarySerializable value)
{
uint written;
CheckSerializationParameters(buffer, start);
if (value != null)
{
Type type = value.GetType();
CheckDefaultConstructor(type);
written = ToBytes(ref buffer, start, type);
written += value.ToBytes(this, ref buffer, start + written);
}
else
{
written = ToBytes(ref buffer, start, (Type)null);
}
return(written);
}
/// <summary>
/// Reads the object.
/// </summary>
/// <returns></returns>
public IBinarySerializable ReadObject()
{
int classId = ReadClassId();
if (classId == 0)
{
return(null);
}
IBinarySerializable obj = null;
switch (classId)
{
case 0:
break;
default:
throw new Exception(string.Format(Strings.ErrorBinarySerializerUnknownObjectType, classId));
}
obj.Deserialize(this);
return(obj);
}
//Отправка сообщения в открытый поток
public void SendMessage(IBinarySerializable message)
{
try
{
if (Client.Connected)
{
message.SerializeBytes(Stream);
}
}
catch (IOException e)
{
if (e.Message == "Unable to write data to the transport connection: An established connection was aborted by the software in your host machine.")
{
Console.WriteLine($"[System] (SendMessage -> {Name}) {e.Message}");
}
}
catch (Exception e)
{
Console.WriteLine($"[System] Some serious problems at SendMessage(IBinarySerializable message): {e.Message}");
}
}
/// <summary>
/// Writes the specified value.
/// </summary>
/// <param name="value">The value.</param>
public void Write(IBinarySerializable value)
{
if (value == null)
WriteClassId(0);
else
value.Serialize(this);
}
public static bool hasSBCompound(this IBinarySerializable bs)
{
return(compounds.ContainsKey(bs.GetType()));
}
public static void Write(IBinarySerializable binaryObject, string file)
{
File.WriteAllBytes(file, Write(binaryObject));
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="encoding"></param>
public NativeBinarySerializable(Encoding encoding)
{
this.encoding = encoding;
this.binarySerializable = new BinarySerializable();
}
private IBinarySerializable SerializeAndDeserializeObject(IBinarySerializable obj, Type objType)
{
dynamic buffer;
using (var stream = new MemoryStream())
{
var binaryWriter = new BinaryWriter(stream);
obj.Write(binaryWriter);
buffer = stream.ToArray();
}
var returnObj = Activator.CreateInstance(objType) as IBinarySerializable;
using (var readStream = new MemoryStream(buffer))
{
var binaryReader = new BinaryReader(readStream);
returnObj.Read(binaryReader);
}
return returnObj;
}
// Custom
public void Write(IBinarySerializable data)
{
data.Serialize(this);
}
public BigEndianDataBuilder Add(IBinarySerializable x)
{
_writer.Write(x);
return(this);
}
public static void Write(this BinaryWriter writer, IBinarySerializable value)
{
value.Serialize(writer);
}
public static void ReadInto(this BinaryReader reader, IBinarySerializable value)
{
value.Deserialize(reader);
}
public void Write(IBinarySerializable serializable)
{
serializable.Serialize(this);
}
/// <summary>
/// Reads and returns an object of the specified type from the current stream.
/// </summary>
/// <param name="type">Type of the object to read.</param>
/// <returns>Object of the specified type read from the current stream.</returns>
public object Deserialize(Type type)
{
// Check for primitive type.
if (type.IsPrimitive())
{
return(this.DeserializePrimitive(type));
}
// Check for string.
if (type == typeof(string))
{
return(this.reader.ReadString());
}
// Check for derived types.
if (type == typeof(ValueWithType))
{
return(this.DeserializeValueWithType());
}
// Check for array.
if (type.IsArray)
{
return(this.DeserializeArray());
}
// Check for list.
if (typeof(IList).IsAssignableFrom(type))
{
return(this.DeserializeList());
}
// Check for dictionary.
if (typeof(IDictionary).IsAssignableFrom(type))
{
return(this.DeserializeDictionary());
}
// Check for enum.
if (type.IsEnum())
{
return(Enum.Parse(type, this.reader.ReadString()));
}
// Check for custom implementation.
if (typeof(IBinarySerializable).IsAssignableFrom(type))
{
IBinarySerializable binarySerializable = (IBinarySerializable)Activator.CreateInstance(type);
binarySerializable.Deserialize(this);
return(binarySerializable);
}
// Deserialize with reflection.
try
{
return(this.DeserializeReflection(type));
}
catch (Exception e)
{
throw new SerializationException(string.Format("Unsupported type: {0}", type.Name), e);
}
}
private void Serialize(object o, Type type)
{
// Check for primitive types.
if (type.IsPrimitive())
{
this.SerializePrimitive(o);
return;
}
// Check for string.
if (type == typeof(string))
{
string s = (string)o;
this.writer.Write(string.IsNullOrEmpty((string)o) ? string.Empty : s);
return;
}
// Check for derived types.
if (type == typeof(ValueWithType))
{
this.SerializeValueWithType((ValueWithType)o);
return;
}
// Check for list.
if (typeof(IList).IsAssignableFrom(type))
{
this.SerializeList((IList)o);
return;
}
// Check for dictionary.
if (typeof(IDictionary).IsAssignableFrom(type))
{
this.SerializeDictionary((IDictionary)o);
return;
}
// Check for enum.
if (type.IsEnum())
{
this.writer.Write(o.ToString());
return;
}
// Check for custom implementation.
if (typeof(IBinarySerializable).IsAssignableFrom(type))
{
IBinarySerializable binarySerializable = (IBinarySerializable)o;
binarySerializable.Serialize(this);
return;
}
// Serialize with reflection.
try
{
this.SerializeReflection(o);
}
catch (Exception e)
{
throw new SerializationException(string.Format("Unsupported type: {0}", type.Name), e);
}
}
public static void Write(this BinaryWriter writer, IBinarySerializable obj)
{
obj.Serialize(writer);
}
public void Write(IBinarySerializable item)
{
item.Serialize(this);
}
public static bool FileExists(this IBinarySerializable item, string filePath)
{
return(File.Exists(filePath) || Directory.Exists(filePath));
}
public static void Save(this IBinarySerializable @this, Stream stream, bool leaveOpen = true)
{
using (var writer = new ObjectBinaryWriter(stream, leaveOpen, Endianness.Little))
@this.Write(writer);
}
public static void DeleteFile(this IBinarySerializable item, string filePath)
{
File.Delete(filePath);
}
public SerializationContext(IBinarySerializable input, Action <Binary.Buffer> callback) : base(callback)
{
this.input = input;
}
/**
*@brief read a class that implements the sulphut.editor.IBinarySerializable interface
*@param[in] obj (sulphut.editor.IBinarySerializable) object to be filled with data from the buffer
*/
public void ReadSerializable(IBinarySerializable obj)
{
obj.Read(this);
}
/// <summary>
/// Writes an item implementing the IBinarySerializable interface to a binary writer. Included for symmetry with standard Writer.Write(X) calls.
/// </summary>
/// <param name="Writer">Writer to serialize to</param>
/// <param name="Item">The item to write</param>
public static void Write(this BinaryWriter Writer, IBinarySerializable Item)
{
Item.Write(Writer);
}
protected static void CallDefaultConstructor(Type type, out IBinarySerializable value)
{
value = (IBinarySerializable)CheckDefaultConstructor(type).Invoke(emptyParameters);
}
