protected internal override void Initialize(IntermediateSerializer serializer)
{
if (base.TargetType.BaseType != null)
{
this.baseSerializer = serializer.GetTypeSerializer(base.TargetType.BaseType);
}
MemberHelperBase <IntermediateSerializer> .CreateMemberHelpers <ReflectiveSerializerMemberHelper>(serializer, base.TargetType, this.memberHelpers);
if (CollectionUtils.IsCollection(base.TargetType, false))
{
this.collectionHelper = serializer.GetCollectionHelper(base.TargetType);
}
object[] customAttributes = base.TargetType.GetCustomAttributes(typeof(ContentSerializerCollectionItemNameAttribute), true);
if (customAttributes.Length == 1)
{
this.collectionItemName = ((ContentSerializerCollectionItemNameAttribute)customAttributes[0]).CollectionItemName;
}
}
/// <summary />
public string GetContentAsXml()
{
if (this.contentAsXml == null)
{
if (base.Count == 0)
{
this.contentAsXml = string.Empty;
}
else
{
StringBuilder stringBuilder = new StringBuilder();
using (XmlWriter xmlWriter = XmlWriter.Create(stringBuilder))
{
IntermediateSerializer.Serialize <OpaqueDataDictionary>(xmlWriter, this, null);
}
this.contentAsXml = stringBuilder.ToString();
}
}
return(this.contentAsXml);
}
internal CollectionHelper(IntermediateSerializer serializer, Type type)
{
this.targetType = type;
Type type2 = CollectionUtils.CollectionElementType(type, false);
if (type2 == null)
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.NotACollectionType, new object[]
{
type
}));
}
this.contentSerializer = serializer.GetTypeSerializer(type2);
Type type3 = typeof(ICollection <>).MakeGenericType(new Type[]
{
type2
});
this.countPropertyGetter = ReflectionEmitUtils.GenerateGetter(type3.GetProperty("Count"));
this.addToCollection = ReflectionEmitUtils.GenerateAddToCollection(type3, type2);
}
/// <summary>Serializes an object into an intermediate XML file.</summary>
/// <param name="output">The output XML stream.</param>
/// <param name="value">The object to be serialized.</param>
/// <param name="referenceRelocationPath">Final name of the output file, used to relative encode external reference filenames.</param>
public static void Serialize <T>(XmlWriter output, T value, string referenceRelocationPath)
{
if (output == null)
{
throw new ArgumentNullException("output");
}
if (value == null)
{
throw new ArgumentNullException("value");
}
Uri baseUri = IntermediateSerializer.RelocationPathToUri(referenceRelocationPath);
IntermediateWriter intermediateWriter = new IntermediateWriter(IntermediateSerializer.SingletonInstance, output, baseUri);
output.WriteStartElement("XnaContent");
new XmlNamespaces(intermediateWriter).WriteNamespaces(value);
ContentSerializerAttribute contentSerializerAttribute = new ContentSerializerAttribute();
contentSerializerAttribute.ElementName = "Asset";
intermediateWriter.WriteObject <object>(value, contentSerializerAttribute);
intermediateWriter.WriteSharedResources();
intermediateWriter.WriteExternalReferences();
output.WriteEndElement();
}
protected internal override void ScanChildren(IntermediateSerializer serializer, ContentTypeSerializer.ChildCallback callback, T[] value)
{
this.arrayHelper.ScanElements(callback, value);
}
protected internal override void Initialize(IntermediateSerializer serializer)
{
this.arrayHelper = serializer.GetCollectionHelper(typeof(T[]));
this.listHelper = serializer.GetCollectionHelper(typeof(List <T>));
}
protected internal override void ScanChildren(IntermediateSerializer serializer, ContentTypeSerializer.ChildCallback callback, List <T> value)
{
this.collectionHelper.ScanElements(callback, value);
}
internal IntermediateReader(IntermediateSerializer serializer, XmlReader xmlReader, Uri baseUri)
{
this.serializer = serializer;
this.xmlReader = xmlReader;
this.baseUri = baseUri;
}
/// <summary>Examines the children of the specified object, passing each to a callback delegate.</summary>
/// <param name="serializer">The content serializer.</param>
/// <param name="callback">The method to be called for each examined child.</param>
/// <param name="value">The object whose children are being scanned.</param>
protected internal override void ScanChildren(IntermediateSerializer serializer, ContentTypeSerializer.ChildCallback callback, object value)
{
this.ScanChildren(serializer, callback, ContentTypeSerializer <T> .CastType(value));
}
/// <summary>Examines the children of the specified object, passing each to a callback delegate.</summary>
/// <param name="serializer">The content serializer.</param>
/// <param name="callback">The method to be called for each examined child.</param>
/// <param name="value">The strongly typed object whose children are being scanned.</param>
protected internal virtual void ScanChildren(IntermediateSerializer serializer, ContentTypeSerializer.ChildCallback callback, T value)
{
}
/// <summary>Retrieves and caches any nested type serializers and allows reflection over the target data type.</summary>
/// <param name="serializer">The content serializer.</param>
protected internal virtual void Initialize(IntermediateSerializer serializer)
{
}
protected internal override void Initialize(IntermediateSerializer serializer)
{
this.underlyingTypeSerializer = serializer.GetTypeSerializer(typeof(T));
this.underlyingFormat = new ContentSerializerAttribute();
this.underlyingFormat.FlattenContent = true;
}