SerializationWriter Methods |
The SerializationWriter type exposes the following members.
Name | Description | |
---|---|---|
AppendTokenTables |
Ensures that the size of the string and object token tables
are appended to the stream and that their offset is written
into the first 4 bytes of the stream.
Does nothing if the stream is not seekable or the constructor
specified not to store presize information.
Notes:
Called automatically by ToArray() otherwise must be called
manually.
| |
Close | Closes the current BinaryWriter and the underlying stream. (Inherited from BinaryWriter.) | |
Dispose | Releases all resources used by the current instance of the BinaryWriter class. (Inherited from BinaryWriter.) | |
DumpTypeUsage |
Dumps the type usage.
| |
Equals | Determines whether the specified object is equal to the current object. (Inherited from Object.) | |
Flush | Clears all buffers for the current writer and causes any buffered data to be written to the underlying device. (Inherited from BinaryWriter.) | |
GetHashCode | Serves as the default hash function. (Inherited from Object.) | |
GetType | Gets the Type of the current instance. (Inherited from Object.) | |
Seek | Sets the position within the current stream. (Inherited from BinaryWriter.) | |
ToArray |
Returns a byte[] containing all of the serialized data
where the underlying stream is a MemoryStream.
Only call this method once all of the data has been serialized.
| |
ToString | Returns a string that represents the current object. (Inherited from Object.) | |
Write(Boolean) | Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true. (Inherited from BinaryWriter.) | |
Write(Byte) | Writes an unsigned byte to the current stream and advances the stream position by one byte. (Inherited from BinaryWriter.) | |
Write(SByte) | Writes a signed byte to the current stream and advances the stream position by one byte. (Inherited from BinaryWriter.) | |
Write(Char) | Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream. (Inherited from BinaryWriter.) | |
Write(Double) | Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. (Inherited from BinaryWriter.) | |
Write(Decimal) | Writes a decimal value to the current stream and advances the stream position by sixteen bytes. (Inherited from BinaryWriter.) | |
Write(Int16) | Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. (Inherited from BinaryWriter.) | |
Write(UInt16) | Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. (Inherited from BinaryWriter.) | |
Write(Int32) | Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. (Inherited from BinaryWriter.) | |
Write(UInt32) | Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. (Inherited from BinaryWriter.) | |
Write(Int64) | Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. (Inherited from BinaryWriter.) | |
Write(UInt64) | Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. (Inherited from BinaryWriter.) | |
Write(Single) | Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. (Inherited from BinaryWriter.) | |
Write(Boolean) |
Writes a Boolean[] into the stream.
Notes:
A null or empty array will take 1 byte.
Calls WriteOptimized(Boolean[]).
| |
Write(Byte) |
Writes a Byte[] into the stream.
Notes:
A null or empty array will take 1 byte.
(Overrides BinaryWriterWrite(Byte).) | |
Write(Char) |
Writes a Char[] into the stream.
Notes:
A null or empty array will take 1 byte.
(Overrides BinaryWriterWrite(Char).) | |
Write(ArrayList) |
Writes an ArrayList into the stream using the fewest number of bytes possible.
Stored Size: 1 byte upwards depending on data content
Notes:
A null Arraylist takes 1 byte.
An empty ArrayList takes 2 bytes.
The contents are stored using WriteOptimized(ArrayList) which should be used
if the ArrayList is guaranteed never to be null.
| |
Write(BitArray) |
Writes a BitArray value into the stream using the fewest number of bytes possible.
Stored Size: 1 byte upwards depending on data content
Notes:
A null BitArray takes 1 byte.
An empty BitArray takes 2 bytes.
| |
Write(BitVector32) |
Writes a BitVector32 into the stream.
Stored Size: 4 bytes.
| |
Write(DateTime) |
Writes a DateTime value into the stream.
Stored Size: 8 bytes
| |
Write(DateTime) |
Writes a DateTime[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(Decimal) |
Writes a Decimal[] into the stream.
Notes:
A null or empty array will take 1 byte.
Calls WriteOptimized(Decimal[]).
| |
Write(Double) |
Writes a Double[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(Guid) |
Writes a Guid into the stream.
Stored Size: 16 bytes.
| |
Write(Guid) |
Writes a Guid[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(Int16) |
Writes an Int16[]or a null into the stream.
Notes:
A null or empty array will take 1 byte.
Calls WriteOptimized(decimal[]).
| |
Write(Int32) |
Writes an Int32[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(Int64) |
Writes an Int64[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(Object) |
Writes an object[] into the stream.
Stored Size: 2 bytes upwards depending on data content
Notes:
A null object[] takes 1 byte.
An empty object[] takes 2 bytes.
The contents of the array will be stored optimized.
| |
Write(SByte) |
Writes an SByte[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(Single) |
Writes a Single[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(String) |
Calls WriteOptimized(string).
This override to hide base BinaryWriter.Write(string).
(Overrides BinaryWriterWrite(String).) | |
Write(TimeSpan) |
Writes a TimeSpan value into the stream.
Stored Size: 8 bytes
| |
Write(TimeSpan) |
Writes a TimeSpan[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(UInt16) |
Writes a UInt16[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(UInt32) |
Writes a UInt32[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(UInt64) |
Writes a UInt64[] into the stream.
Notes:
A null or empty array will take 1 byte.
| |
Write(Type, Boolean) |
Stores a Type object into the stream.
Stored Size: Depends on the length of the Type's name and whether the fullyQualified parameter is set.
A null Type takes 1 byte.
| |
Write(IOwnedDataSerializable, Object) |
Allows any object implementing IOwnedDataSerializable to serialize itself
into this SerializationWriter.
A context may also be used to give the object an indication of what data
to store. As an example, using a BitVector32 gives a list of flags and
the object can conditionally store data depending on those flags.
| |
Write(Byte, Int32, Int32) | Writes a region of a byte array to the current stream. (Inherited from BinaryWriter.) | |
Write(Char, Int32, Int32) | Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream. (Inherited from BinaryWriter.) | |
WriteT(ListT) |
Writes a non-null generic List into the stream.
| |
WriteK, V(DictionaryK, V) |
Writes a non-null generic Dictionary into the stream.
| |
WriteBytesDirect |
Writes a byte[] directly into the stream.
The size of the array is not stored so only use this method when
the number of bytes will be known at deserialization time.
A null value will throw an exception
| |
WriteNullable |
Writes a Nullable type into the stream.
Synonym for WriteObject().
| |
WriteObject |
Stores an object into the stream using the fewest number of bytes possible.
Stored Size: 1 byte upwards depending on type and/or content.
1 byte: null, DBNull.Value, Boolean
1 to 2 bytes: Int16, UInt16, Byte, SByte, Char,
1 to 4 bytes: Int32, UInt32, Single, BitVector32
1 to 8 bytes: DateTime, TimeSpan, Double, Int64, UInt64
1 or 16 bytes: Guid
1 plus content: string, object[], byte[], char[], BitArray, Type, ArrayList
Any other object be stored using a .Net Binary formatter but this should
only be allowed as a last resort:
Since this is effectively a different serialization session, there is a
possibility of the same shared object being serialized twice or, if the
object has a reference directly or indirectly back to the parent object,
there is a risk of looping which will throw an exception.
The type of object is checked with the most common types being checked first.
Each 'section' can be reordered to provide optimum speed but the check for
null should always be first and the default serialization always last.
Once the type is identified, a SerializedType byte is stored in the stream
followed by the data for the object (certain types/values may not require
storage of data as the SerializedType may imply the value).
For certain objects, if the value is within a certain range then optimized
storage may be used. If the value doesn't meet the required optimization
criteria then the value is stored directly.
The checks for optimization may be disabled by setting the OptimizeForSize
property to false in which case the value is stored directly. This could
result in a slightly larger stream but there will be a speed increate to
compensate.
| |
WriteOptimized(Boolean) |
Writes an optimized Boolean[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
Stored as a BitArray.
| |
WriteOptimized(ArrayList) |
Writes an non-null ArrayList into the stream using the fewest number of bytes possible.
Stored Size: 1 byte upwards depending on data content
Notes:
An empty ArrayList takes 1 byte.
| |
WriteOptimized(BitArray) |
Writes a BitArray into the stream using the fewest number of bytes possible.
Stored Size: 1 byte upwards depending on data content
Notes:
An empty BitArray takes 1 byte.
| |
WriteOptimized(BitVector32) |
Writes a BitVector32 into the stream using the fewest number of bytes possible.
Stored Size: 1 to 4 bytes. (.Net is 4 bytes)
1 to 7 bits takes 1 byte
8 to 14 bits takes 2 bytes
15 to 21 bits takes 3 bytes
22 to 28 bits takes 4 bytes
-------------------------------------------------------------------
29 to 32 bits takes 5 bytes - use Write(BitVector32) method instead
Try to order the BitVector32 masks so that the highest bits are least-likely
to be set.
| |
WriteOptimized(DateTime) |
Writes a DateTime value into the stream using the fewest number of bytes possible.
Stored Size: 3 bytes to 7 bytes (.Net is 8 bytes)
Notes:
A DateTime containing only a date takes 3 bytes
(except a .NET 2.0 Date with a specified DateTimeKind which will take a minimum
of 5 bytes - no further optimization for this situation felt necessary since it
is unlikely that a DateTimeKind would be specified without hh:mm also)
Date plus hh:mm takes 5 bytes.
Date plus hh:mm:ss takes 6 bytes.
Date plus hh:mm:ss.fff takes 7 bytes.
| |
WriteOptimized(DateTime) |
Writes a DateTime[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(Decimal) |
Writes a Decimal value into the stream using the fewest number of bytes possible.
Stored Size: 1 byte to 14 bytes (.Net is 16 bytes)
Restrictions: None
| |
WriteOptimized(Decimal) |
Writes a Decimal[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(Int16) |
Write an Int16 value using the fewest number of bytes possible.
| |
WriteOptimized(Int16) |
Writes an Int16[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(Int32) |
Write an Int32 value using the fewest number of bytes possible.
| |
WriteOptimized(Int32) |
Writes an Int32[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(Int64) |
Write an Int64 value using the fewest number of bytes possible.
| |
WriteOptimized(Int64) |
Writes an Int64[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(Object) |
Writes a not-null object[] into the stream using the fewest number of bytes possible.
Stored Size: 2 bytes upwards depending on data content
Notes:
An empty object[] takes 1 byte.
The contents of the array will be stored optimized.
| |
WriteOptimized(String) |
Writes a string value into the stream using the fewest number of bytes possible.
Stored Size: 1 byte upwards depending on string length
Notes:
Encodes null, Empty, 'Y', 'N', ' ' values as a single byte
Any other single char string is stored as two bytes
All other strings are stored in a string token list:
The TypeCode representing the current string token list is written first (1 byte),
followed by the string token itself (1-4 bytes)
When the current string list has reached 128 values then a new string list
is generated and that is used for generating future string tokens. This continues
until the maximum number (128) of string lists is in use, after which the string
lists are used in a round-robin fashion.
By doing this, more lists are created with fewer items which allows a smaller
token size to be used for more strings.
The first 16,384 strings will use a 1 byte token.
The next 2,097,152 strings will use a 2 byte token. (This should suffice for most uses!)
The next 268,435,456 strings will use a 3 byte token. (My, that is a lot!!)
The next 34,359,738,368 strings will use a 4 byte token. (only shown for completeness!!!)
| |
WriteOptimized(TimeSpan) |
Writes a TimeSpan value into the stream using the fewest number of bytes possible.
Stored Size: 2 bytes to 8 bytes (.Net is 8 bytes)
Notes:
hh:mm (time) are always stored together and take 2 bytes.
If seconds are present then 3 bytes unless (time) is not present in which case 2 bytes
since the seconds are stored in the minutes position.
If milliseconds are present then 4 bytes.
In addition, if days are present they will add 1 to 4 bytes to the above.
| |
WriteOptimized(TimeSpan) |
Writes a TimeSpan[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(Type) |
Stores a non-null Type object into the stream.
Stored Size: Depends on the length of the Type's name.
If the type is a System type (mscorlib) then it is stored without assembly name information,
otherwise the Type's AssemblyQualifiedName is used.
| |
WriteOptimized(UInt16) |
Write a UInt16 value using the fewest number of bytes possible.
| |
WriteOptimized(UInt16) |
Writes a UInt16[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(UInt32) |
Write a UInt32 value using the fewest number of bytes possible.
| |
WriteOptimized(UInt32) |
Writes a UInt32[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(UInt64) |
Write a UInt64 value using the fewest number of bytes possible.
| |
WriteOptimized(UInt64) |
Writes a UInt64[] into the stream using the fewest possible bytes.
Notes:
A null or empty array will take 1 byte.
| |
WriteOptimized(Object, Object) |
Writes a pair of object[] arrays into the stream using the fewest number of bytes possible.
The arrays must not be null and must have the same length
The first array's values are written optimized
The second array's values are compared against the first and, where identical, will be stored
using a single byte.
Useful for storing entity data where there is a before-change and after-change set of value pairs
and, typically, only a few of the values will have changed.
| |
WriteStringDirect |
Writes a non-null string directly to the stream without tokenization.
| |
WriteTokenizedObject(Object) |
Writes a token (an Int32 taking 1 to 4 bytes) into the stream that represents the object instance.
The same token will always be used for the same object instance.
The object will be serialized once and recreated at deserialization time.
Calls to SerializationReader.ReadTokenizedObject() will retrieve the same object instance.
| |
WriteTokenizedObject(Object, Boolean) |
Writes a token (an Int32 taking 1 to 4 bytes) into the stream that represents the object instance.
The same token will always be used for the same object instance.
When recreateFromType is set to true, the object's Type will be stored and the object recreated using
Activator.GetInstance with a parameterless contructor. This is useful for stateless, factory-type classes.
When recreateFromType is set to false, the object will be serialized once and recreated at deserialization time.
Calls to SerializationReader.ReadTokenizedObject() will retrieve the same object instance.
| |
WriteTypedArray |
Writes a null or a typed array into the stream.
|