Creates a FastSerializer with the Default Capacity (1kb)

Creates a FastSerializer with the specified capacity

Creates a FastSerializer around the specified stream Will store token table presize info if the stream is seekable

Creates a FastSerializer around the specified stream Notes: If the stream is not seekable then the allowStoreTokenTablePresizeInfo parameter is ignored

Gets a boolean flag which indicates whether AppendTokenTables will store the presize information for the string and object token tables.

Gets the underlying stream of the BinaryWriter.

Returns the number of objects in the object token table.

Gets or Sets a boolean flag to indicate whether to optimize for size (default) by storing data as packed bits or sections where possible. Setting this value to false will turn off this optimization and store data directly which increases the speed. Note: This only affects optimization of data passed to the WriteObject method and direct calls to the WriteOptimized methods will always pack data into the smallest space where possible.

Gets or Sets a boolean flag to indicate whether to preserve the scale within a Decimal value when it would have no effect on the represented value. Note: a 2m value and a 2.00m value represent the same value but internally they are stored differently - the former has a value of 2 and a scale of 0 and the latter has a value of 200 and a scale of 2. The scaling factor also preserves any trailing zeroes in a Decimal number. Trailing zeroes do not affect the value of a Decimal number in arithmetic or comparison operations. However, trailing zeroes can be revealed by the ToString method if an appropriate format string is applied. From a serialization point of view, the former will take 2 bytes whereas the latter would take 4 bytes, therefore it is preferable to not save the scale where it doesn't affect the represented value.

Returns the number of strings in the string token table.

gets the list of optional IFastSerializationTypeSurrogate instances which SerializationWriter and SerializationReader will use to serialize objects not directly supported. It is important to use the same list on both client and server ends to ensure that the same surrogated-types are supported.

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.

Closes the current BinaryWriter and the underlying stream.

Releases all resources used by the current instance of the BinaryWriter class.

Dumps the type usage.

Determines whether the specified object is equal to the current object.

Clears all buffers for the current writer and causes any buffered data to be written to the underlying device.

Serves as the default hash function.

Gets the Type of the current instance.

Sets the position within the current stream.

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.

Returns a string that represents the current object.

Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true.

Writes an unsigned byte to the current stream and advances the stream position by one byte.

Writes a signed byte to the current stream and advances the stream position by one byte.

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.

Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes.

Writes a decimal value to the current stream and advances the stream position by sixteen bytes.

Writes a two-byte signed integer to the current stream and advances the stream position by two bytes.

Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes.

Writes a four-byte signed integer to the current stream and advances the stream position by four bytes.

Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes.

Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes.

Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes.

Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes.

Writes a Boolean[] into the stream. Notes: A null or empty array will take 1 byte. Calls WriteOptimized(Boolean[]).

Writes a Byte[] into the stream. Notes: A null or empty array will take 1 byte.

Writes a Char[] into the stream. Notes: A null or empty array will take 1 byte.

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.

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.

Writes a BitVector32 into the stream. Stored Size: 4 bytes.

Writes a DateTime value into the stream. Stored Size: 8 bytes

Writes a DateTime[] into the stream. Notes: A null or empty array will take 1 byte.

Writes a Decimal[] into the stream. Notes: A null or empty array will take 1 byte. Calls WriteOptimized(Decimal[]).

Writes a Double[] into the stream. Notes: A null or empty array will take 1 byte.

Writes a Guid into the stream. Stored Size: 16 bytes.

Writes a Guid[] into the stream. Notes: A null or empty array will take 1 byte.

Writes an Int16[]or a null into the stream. Notes: A null or empty array will take 1 byte. Calls WriteOptimized(decimal[]).

Writes an Int32[] into the stream. Notes: A null or empty array will take 1 byte.

Writes an Int64[] into the stream. Notes: A null or empty array will take 1 byte.

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.

Writes an SByte[] into the stream. Notes: A null or empty array will take 1 byte.

Writes a Single[] into the stream. Notes: A null or empty array will take 1 byte.

Calls WriteOptimized(string). This override to hide base BinaryWriter.Write(string).

Writes a TimeSpan value into the stream. Stored Size: 8 bytes

Writes a TimeSpan[] into the stream. Notes: A null or empty array will take 1 byte.

Writes a UInt16[] into the stream. Notes: A null or empty array will take 1 byte.

Writes a UInt32[] into the stream. Notes: A null or empty array will take 1 byte.

Writes a UInt64[] into the stream. Notes: A null or empty array will take 1 byte.

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.

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.

Writes a region of a byte array to the current stream.

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.

Writes a non-null generic List into the stream.

Writes a non-null generic Dictionary into the stream.

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

Writes a Nullable type into the stream. Synonym for 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.

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.

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.

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.

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.

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.

Writes a DateTime[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

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

Writes a Decimal[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

Write an Int16 value using the fewest number of bytes possible.

Writes an Int16[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

Write an Int32 value using the fewest number of bytes possible.

Writes an Int32[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

Write an Int64 value using the fewest number of bytes possible.

Writes an Int64[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

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.

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!!!)

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.

Writes a TimeSpan[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

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.

Write a UInt16 value using the fewest number of bytes possible.

Writes a UInt16[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

Write a UInt32 value using the fewest number of bytes possible.

Writes a UInt32[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

Write a UInt64 value using the fewest number of bytes possible.

Writes a UInt64[] into the stream using the fewest possible bytes. Notes: A null or empty array will take 1 byte.

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.

Writes a non-null string directly to the stream without tokenization.

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.

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.

Writes a null or a typed array into the stream.

Default capacity for the underlying MemoryStream

The Default setting for the OptimizeForSize property.

The Default setting for the PreserveDecimalScale property.

Holds the highest Int16 that can be optimized into less than the normal 2 bytes

Holds the highest Int32 that can be optimized into less than the normal 4 bytes

Holds the highest Int64 that can be optimized into less than the normal 8 bytes