/// <summary>Unmarshals data from the given stream</summary>
/// <param name="o">object to unmarshal into</param>
/// <param name="stream">stream to unmarshal data from</param>
static public void DeSerialize(object o, Stream stream)
{
BinaryReader reader = new BinaryReader(stream);
BinarySerializer.DeserializeFields(reader, o);
}
/// <summary>Marshals data to a stream</summary>
/// <param name="o">object to marshal</param>
/// <param name="stream">stream to marshal the data to</param>
static public void Serialize(object o, Stream stream)
{
BinaryWriter writer = new BinaryWriter(stream);
BinarySerializer.SerializeFields(writer, o);
}
static private object InternalDeserializeInstance(BinaryReader reader, object o, Type t)
{
if (o != null)
{
t = o.GetType( );
}
if (o != null && (o.GetType( ) != t))
{
throw new ArgumentException("type 't' doesn't match provided object 'o'");
}
if (t == typeof(Boolean))
{
return(reader.ReadBoolean( ));
}
if (t == typeof(Char))
{
return(reader.ReadChar( ));
}
if (t == typeof(SByte))
{
return(reader.ReadSByte( ));
}
if (t == typeof(Byte))
{
return(reader.ReadByte( ));
}
if (t == typeof(Int16))
{
return(reader.ReadInt16( ));
}
if (t == typeof(UInt16))
{
return(reader.ReadUInt16( ));
}
if (t == typeof(Int32))
{
return(reader.ReadInt32( ));
}
if (t == typeof(UInt32))
{
return(reader.ReadUInt32( ));
}
if (t == typeof(Int64))
{
return(reader.ReadInt64( ));
}
if (t == typeof(UInt64))
{
return(reader.ReadUInt64( ));
}
//
// if(t==typeof(Single))
// return reader.ReadSingle();
//
// if(t==typeof(Double))
// return reader.ReadDouble();
if (t == typeof(String))
{
return(reader.ReadString( ));
}
// arrays introduce too many complications to support at this time
// far to many border or special case considerations need to be accounted
// for; the entire implementation of this class needs a re-design to
// do that adequately.
if (t.IsArray)
{
throw new ArgumentException("Arrays are not supported for serialization");
}
if (!t.IsValueType && !t.IsClass)
{
throw new ArgumentException("unsupported type for parameter 'o'");
}
BinarySerializer.DeserializeFields(reader, o);
return(o);
}
static private void InternalSerializeInstance(BinaryWriter writer, object o, Type t)
{
if (t == typeof(Boolean))
{
writer.Write(( Boolean )o);
return;
}
if (t == typeof(Char))
{
writer.Write(( Char )o);
return;
}
if (t == typeof(SByte))
{
writer.Write(( SByte )o);
return;
}
if (t == typeof(Byte))
{
writer.Write(( Byte )o);
return;
}
if (t == typeof(Int16))
{
writer.Write(( Int16 )o);
return;
}
if (t == typeof(UInt16))
{
writer.Write(( UInt16 )o);
return;
}
if (t == typeof(Int32))
{
writer.Write(( Int32 )o);
return;
}
if (t == typeof(UInt32))
{
writer.Write(( UInt32 )o);
return;
}
if (t == typeof(Int64))
{
writer.Write(( Int64 )o);
return;
}
if (t == typeof(UInt64))
{
writer.Write(( UInt64 )o);
return;
}
//if (t == typeof(Single))
//{
// writer.Write((Single)o);
// return;
//}
//if (t == typeof(Double))
//{
// writer.Writer((Double)o);
// return;
//}
if (t == typeof(String))
{
if (o == null)
{
writer.Write(string.Empty);
}
else
{
writer.Write(( String )o);
}
return;
}
// arrays introduce too many complications to support at this time
// far to many border or special case considerations need to be accounted
// for; the entire implementation of this class needs a re-design to
// do that adequately.
if (t.IsArray)
{
throw new ArgumentException("Arrays are not supported for serialization");
}
if (!t.IsValueType && !t.IsClass)
{
throw new ArgumentException("unsupported type", "o");
}
BinarySerializer.InternalSerializeFields(writer, o, t);
}
/// <summary>Unmarshals a data object from a byte array</summary>
/// <param name="o">Object to unmarshal the byte array into</param>
/// <param name="buf">byte array containing Marshalled data to unmarshal</param>
static public void DeSerialize(object o, byte[] buf)
{
MemoryStream stream = new MemoryStream((buf != null) ? buf : new byte[1]);
BinarySerializer.DeSerialize(o, stream);
}
