internal static int Serialize(T instance, SerializationContext context)
{
// check for inheritance; if the instance is a subclass, then we
// should serialize the sub-type first, allowing for more efficient
// deserialization; note that we don't push the instance onto the
// stack yet - we'll do that within each instance (otherwise deep
// items could incorrectly count as cyclic).
Type actualType = instance.GetType();
int total = 0, len;
Callback(CallbackType.BeforeSerialization, instance);
if (actualType != typeof(T))
{
bool subclassFound = false;
foreach (KeyValuePair <Type, Property <T, T> > subclass in subclasses)
{
if (subclass.Key.IsAssignableFrom(actualType))
{
total += subclass.Value.Serialize(instance, context);
subclassFound = true;
break;
}
}
if (!subclassFound)
{
throw new ProtoException("Unexpected type found during serialization; types must be included with ProtoIncludeAttribute; "
+ "found " + actualType.Name + " passed as " + typeof(T).Name);
}
}
context.Push(instance);
for (int i = 0; i < writeProps.Length; i++)
{
// note that this serialization includes the headers...
total += writeProps[i].Serialize(instance, context);
}
IExtensible extensible = instance as IExtensible;
IExtension extra = extensible == null ? null : extensible.GetExtensionObject(false);
if (extra != null && (len = extra.GetLength()) > 0)
{
Stream extraStream = extra.BeginQuery();
try
{
context.WriteFrom(extraStream, len);
total += len;
}
finally
{
extra.EndQuery(extraStream);
}
}
context.Pop(instance);
Callback(CallbackType.AfterSerialization, instance);
return(total);
}