private void Serialise(
object value,
Type type,
bool populatingDeferredObject,
Stack <object> parentsIfReferenceReuseDisallowed,
Dictionary <object, int> objectHistoryIfReferenceReuseAllowed,
HashSet <int> deferredInitialisationObjectReferenceIDsIfSupported,
Dictionary <Type, Action <object> > generatedMemberSetters,
ISerialisationTypeConverter[] typeConverters,
IWrite writer)
{
if ((parentsIfReferenceReuseDisallowed != null) && parentsIfReferenceReuseDisallowed.Contains(value, ReferenceEqualityComparer.Instance))
{
throw new CircularReferenceException();
}
// Give the type converters a crack at the current value - if any of them change the value then take that as the new value and don't consider any other converters
foreach (var typeConverter in typeConverters)
{
var updatedValue = typeConverter.ConvertIfRequired(value);
if (!ReferenceEquals(updatedValue, value))
{
value = updatedValue;
type = value?.GetType() ?? typeof(object);
break;
}
}
// If we've got a Nullable<> then unpack the internal value/type - if it's null then we'll get a null ObjectStart/ObjectEnd value which the BinarySerialisationReader will
// happily interpret (reading it as a null and setting the Nullable<> field) and if it's non-null then we'll serialise just the value itself (again, the reader will take
// that value and happily set a Nullable<> field - so if we write an int then the reader will read the int and set the int? field just fine). Doing this means that we
// have less work to do (otherwise we'd record the Nullable<> as an object and write the type name and so it's just more work to write, more work to read and takes
// up more data in the serialisation output).
if ((value != null) && type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
type = type.GetGenericArguments()[0];
}
if (type == CommonTypeOfs.Boolean)
{
writer.Boolean((Boolean)value);
return;
}
if (type == CommonTypeOfs.Byte)
{
writer.Byte((Byte)value);
return;
}
if (type == CommonTypeOfs.SByte)
{
writer.SByte((SByte)value);
return;
}
if (type == CommonTypeOfs.Int16)
{
writer.Int16((Int16)value);
return;
}
if (type == CommonTypeOfs.Int32)
{
writer.Int32((Int32)value);
return;
}
if (type == CommonTypeOfs.Int64)
{
writer.Int64((Int64)value);
return;
}
if (type == CommonTypeOfs.UInt16)
{
writer.UInt16((UInt16)value);
return;
}
if (type == CommonTypeOfs.UInt32)
{
writer.UInt32((UInt32)value);
return;
}
if (type == CommonTypeOfs.UInt64)
{
writer.UInt64((UInt64)value);
return;
}
if (type == CommonTypeOfs.Single)
{
writer.Single((Single)value);
return;
}
if (type == CommonTypeOfs.Double)
{
writer.Double((Double)value);
return;
}
if (type == CommonTypeOfs.Decimal)
{
writer.Decimal((Decimal)value);
return;
}
if (type == CommonTypeOfs.Char)
{
writer.Char((Char)value);
return;
}
if (type == CommonTypeOfs.String)
{
if (value == null)
{
writer.Null();
}
else
{
writer.String((String)value);
}
return;
}
if (type == CommonTypeOfs.DateTime)
{
writer.DateTime((DateTime)value);
return;
}
if (type == CommonTypeOfs.TimeSpan)
{
writer.TimeSpan((TimeSpan)value);
return;
}
if (type == CommonTypeOfs.Guid)
{
writer.Guid((Guid)value);
return;
}
// For Object and Array types, if we've got a null reference then write a Null value (having this null check here avoids the type.IsEnum and type.IsArray checks
// for cases where we DO have a null reference(
if (value == null)
{
writer.Null();
return;
}
if (type.IsEnum)
{
Serialise(
value,
type.GetEnumUnderlyingType(),
false, // populatingDeferredObject is never applicable to enum values as they are not reference types
parentsIfReferenceReuseDisallowed,
objectHistoryIfReferenceReuseAllowed,
deferredInitialisationObjectReferenceIDsIfSupported,
generatedMemberSetters,
typeConverters,
writer
);
return;
}
if (type.IsArray)
{
// TODO: Need to ensure that de/serialising arrays with multiple dimensions works!
var elementType = type.GetElementType();
writer.ArrayStart(value, elementType);
var array = (Array)value;
Dictionary <int, object> newObjectReferencesFromArray;
HashSet <int> deferredInitialisationObjectReferenceIDs;
if (deferredInitialisationObjectReferenceIDsIfSupported != null)
{
// If deferredInitialisationObjectReferenceIDsIfSupported is non-null then it means that we're operating in an optimise-for-wide-circular-references mode
// and we want to take a breadth-first approach to serialising arrays - we want to build up a list of all object that are array elements and we'll put
// them in a special "delayed content-population" / "deferred initialisation" list and then, when the array data is serialised, instead of us diving
// deep into each object to write out its contents, we'll just include the Object Reference ID to one of these deferred-initialisation objects. After
// the array has been serialised, we'll write out the information that allows these not-yet-populated object references to have all of their fields
// set. I'm finding it difficult to describe this well so I'll go with an example - the source data is an array of items A1, A2, A3 and each of these
// items has a property that is an array that contains B1, B2, B3 (all of A1, A2, A3 reference the same B1, B2, B3 in an array property). All of these
// B1, B2, B3 items have a property that is an array that includes references to A1, A2, A3 and so there are circular references throughout. If this was
// approach like a tree structure then we would start serialising A1 and we'd encounter its array property and so we'd start serialising B1 and then ITS
// array property would include A1 (which we'd include an Object Reference ID for because we've already encountered A1) but we'd then have to serialise
// A2 and A2 would lead to B2, etc.. and each of these jumps would be another Serialise call and the call stack would grow and grow and grow. If we use
// THIS approach (instead of treating it as a tree) then we start with the array A1, A2, A3 and we create Object References for them and then start to
// serialise A1 - this leads to A1's array of B1, B2, B3 and we create Object References for them and then serialise each of them; when they reference
// A1, A2, A3 we will be able to record Object Reference IDs because we've already encountered A1, A2, A3. This way, the call stack is kept much more
// shallow (when there are only 3-element arrays, there isn't any real problem but if the arrays have 1000s of elements then a stack overflow exception
// is likely to occur if the data is serialised as a tree). The disadvantage to this approach is that it is less intuitive and it involves defining
// objects in two passes (first to say "here is an object reference which currently is missing data" and then a second to say "here is the data for that
// earlier object") - this affects both the serialisation process AND the deserialisation process. There are also some optimisations which the reader
// can't make if the object creation / population is spread out (but taking that hit is might be the only option if you have an object model that will
// cause a stack overflow if you don't!)
newObjectReferencesFromArray = new Dictionary <int, object>();
if (!IsTreatedAsPrimitive(elementType))
{
for (var i = 0; i < array.Length; i++)
{
// Note: We want to identify the objects that are referenced DIRECTLY by this array element (we don't want to try to follow the whole chain or
// we run the risk of a stack overflow again). However, if the element is a struct then we may need to walk down its members until we do find
// the object references (eg. if we have an array of KeyValuePair<TKey, TEntry> then find the object references by looking at the Key and
// Value properties of the KeyValuePair struct) - this is handled by the PrepareArrayObjectReferences method.
var element = array.GetValue(i);
PrepareArrayObjectReferences(element, elementType, objectHistoryIfReferenceReuseAllowed, newObjectReferencesFromArray, writer);
}
}
if (newObjectReferencesFromArray.Any())
{
deferredInitialisationObjectReferenceIDs = new HashSet <int>(deferredInitialisationObjectReferenceIDsIfSupported);
deferredInitialisationObjectReferenceIDs.UnionWith(newObjectReferencesFromArray.Keys);
}
else
{
deferredInitialisationObjectReferenceIDs = deferredInitialisationObjectReferenceIDsIfSupported;
}
}
else
{
newObjectReferencesFromArray = null;
deferredInitialisationObjectReferenceIDs = null;
}
if (parentsIfReferenceReuseDisallowed != null)
{
parentsIfReferenceReuseDisallowed.Push(value);
}
for (var i = 0; i < array.Length; i++)
{
var element = array.GetValue(i);
Serialise(
element,
elementType,
false, // populatingDeferredObject should only ever be true in the Serialise call below
parentsIfReferenceReuseDisallowed,
objectHistoryIfReferenceReuseAllowed,
deferredInitialisationObjectReferenceIDs,
generatedMemberSetters,
typeConverters,
writer
);
}
if (parentsIfReferenceReuseDisallowed != null)
{
parentsIfReferenceReuseDisallowed.Pop();
}
if (newObjectReferencesFromArray != null)
{
foreach (var deferredObject in newObjectReferencesFromArray.Values)
{
Serialise(
deferredObject,
deferredObject.GetType(),
true, // Pass true for populatingDeferredObject to indicate that we need to record data that will used to populate an delayed-content-population reference
parentsIfReferenceReuseDisallowed,
objectHistoryIfReferenceReuseAllowed,
deferredInitialisationObjectReferenceIDsIfSupported,
generatedMemberSetters,
typeConverters,
writer
);
}
}
writer.ArrayEnd();
return;
}
writer.ObjectStart(value.GetType());
bool recordedAsOtherReference, recordedAsPostponedReference;
if ((objectHistoryIfReferenceReuseAllowed != null) && IsApplicableToObjectHistory(type))
{
if (objectHistoryIfReferenceReuseAllowed.TryGetValue(value, out int referenceID))
{
recordedAsOtherReference = true;
recordedAsPostponedReference = (deferredInitialisationObjectReferenceIDsIfSupported != null) && deferredInitialisationObjectReferenceIDsIfSupported.Contains(referenceID);
}
else
{
if (objectHistoryIfReferenceReuseAllowed.Count == BinaryReaderWriterShared.MaxReferenceCount)
{
// The references need to be tracked in the object history dictionary and there is a limit to how many items will fit (MaxReferenceCount will be int.MaxValue) -
// this probably won't ever be hit (more likely to run out of memory first) but it's better to have a descriptive exception in case it ever is encountered
throw new MaxObjectGraphSizeExceededException();
}
referenceID = objectHistoryIfReferenceReuseAllowed.Count;
objectHistoryIfReferenceReuseAllowed[value] = referenceID;
recordedAsOtherReference = false;
recordedAsPostponedReference = false;
}
writer.ReferenceId(referenceID);
}
else
{
recordedAsOtherReference = false;
recordedAsPostponedReference = false;
}
if (recordedAsPostponedReference)
{
writer.ObjectContentPostponed();
}
else if (!recordedAsOtherReference || populatingDeferredObject)
{
// If this object is associated with an Object Reference ID that has been encountered before then we won't to repeat the information for the fields on that object
// (because this would have been written the first time that the object was met). However, if the first time that the object was declared was for deferred
// initialisation (which is used in OptimiseForWideCircularReferences configurations) then this might be the time that the content for that object needs
// to be recorded - in which case, the populatingDeferredObject will be true.
SerialiseObjectFieldsAndProperties(
value,
parentsIfReferenceReuseDisallowed,
objectHistoryIfReferenceReuseAllowed,
deferredInitialisationObjectReferenceIDsIfSupported,
generatedMemberSetters,
typeConverters,
writer
);
}
writer.ObjectEnd();
}
