private void WriteObjectString(
XmlWriter writer, string property, object source, TypeSerializationInfo entry)
{
if (property != null)
{
WriteStartElement(writer, CustomSerializationStrings.Properties);
WriteAttribute(writer, CustomSerializationStrings.NameAttribute, property);
}
else
{
if (_firstcall)
{
WriteStartElement(writer, CustomSerializationStrings.PSObjectTag);
_firstcall = false;
}
else
{
WriteStartElement(writer, CustomSerializationStrings.Properties);
}
}
if (!_notypeinformation)
{
WriteAttribute(writer, CustomSerializationStrings.TypeAttribute, source.GetType().ToString());
}
writer.WriteString(source.ToString());
writer.WriteEndElement();
}
private void HandlePSObjectAsString(PSObject source, string property, int depth)
{
Dbg.Assert(source != null, "caller should validate the information");
bool hasNotes = PSObjectHasNotes(source);
string value = GetStringFromPSObject(source);
if (value != null)
{
TypeSerializationInfo pktInfo = KnownTypes.GetTypeSerializationInfo(value.GetType());
Dbg.Assert(pktInfo != null, "TypeSerializationInfo should be present for string");
if (hasNotes)
{
WritePrimitiveTypePSObjectWithNotes(source, value, pktInfo, property, depth);
}
else
{
WriteOnePrimitiveKnownType(_writer, property, source.BaseObject, pktInfo);
}
}
else
{
if (hasNotes)
{
WritePrimitiveTypePSObjectWithNotes(source, null, null, property, depth);
}
else
{
WriteNull(property);
}
}
}
/// <summary>
/// Serializes an PSObject whose baseobject is of primitive type.
/// and which has notes.
/// </summary>
/// <param name="source">
/// Source from which notes are written.
/// </param>
/// <param name="primitive">
/// primitive object which is written as base object. In most cases it
/// is same source.ImmediateBaseObject. When PSObject is serialized as string,
/// it can be different. <see cref="HandlePSObjectAsString"/> for more info.
/// </param>
/// <param name="pktInfo">
/// TypeSerializationInfo for the primitive.
/// </param>
/// <param name="property"></param>
/// <param name="depth"></param>
private void WritePrimitiveTypePSObjectWithNotes(
PSObject source,
object primitive,
TypeSerializationInfo pktInfo,
string property,
int depth)
{
Dbg.Assert(source != null, "caller should validate the parameter");
//Write start of PSObject. Since baseobject is primitive known
//type, we do not need TypeName information.
WriteStartOfPSObject(source, property, source.ToStringFromDeserialization != null);
if (pktInfo != null)
{
WriteOnePrimitiveKnownType(_writer, null, primitive, pktInfo);
}
//Serialize instanceMembers
PSMemberInfoCollection <PSMemberInfo> instanceMembers = source.InstanceMembers;
if (instanceMembers != null)
{
WriteMemberInfoCollection(instanceMembers, depth, true);
}
_writer.WriteEndElement();
}
internal static TypeSerializationInfo GetTypeSerializationInfo(Type type)
{
TypeSerializationInfo xdInfo = (TypeSerializationInfo)KnownTypes._knownTableKeyType[(object)type.FullName];
if (xdInfo == null && typeof(XmlDocument).IsAssignableFrom(type))
{
xdInfo = KnownTypes._xdInfo;
}
return(xdInfo);
}
internal static TypeSerializationInfo GetTypeSerializationInfo(Type type)
{
TypeSerializationInfo info = (TypeSerializationInfo)_knownTableKeyType[type.FullName];
if ((info == null) && typeof(XmlDocument).IsAssignableFrom(type))
{
info = _xdInfo;
}
return(info);
}
private bool HandlePrimitiveKnownType(object source, string property)
{
TypeSerializationInfo typeSerializationInfo = KnownTypes.GetTypeSerializationInfo(source.GetType());
if (typeSerializationInfo != null)
{
this.WriteOnePrimitiveKnownType(this._writer, property, source, typeSerializationInfo);
return(true);
}
return(false);
}
/// <summary>
/// Serializes Primitive Known Types.
/// </summary>
/// <returns>
/// true if source is handled, else false.
/// </returns>
private bool HandlePrimitiveKnownType(object source, string property)
{
Dbg.Assert(source != null, "caller should validate the parameter");
//Check if source is of primitive known type
TypeSerializationInfo pktInfo = KnownTypes.GetTypeSerializationInfo(source.GetType());
if (pktInfo != null)
{
WriteOnePrimitiveKnownType(_writer, property, source, pktInfo);
return(true);
}
return(false);
}
private bool HandlePrimitiveKnownTypePSObject(object source, string property, int depth)
{
bool flag = false;
PSObject obj2 = source as PSObject;
if ((obj2 != null) && !obj2.immediateBaseObjectIsEmpty)
{
object immediateBaseObject = obj2.ImmediateBaseObject;
TypeSerializationInfo typeSerializationInfo = KnownTypes.GetTypeSerializationInfo(immediateBaseObject.GetType());
if (typeSerializationInfo != null)
{
this.WriteOnePrimitiveKnownType(this._writer, property, immediateBaseObject, typeSerializationInfo);
flag = true;
}
}
return(flag);
}
/// <summary>
/// Serializes PSObject whose base objects are of primitive known type
/// </summary>
/// <param name="source"></param>
/// <param name="property"></param>
/// <param name="depth"></param>
/// <returns>
/// true if source is handled, else false.
/// </returns>
private bool HandlePrimitiveKnownTypePSObject(object source, string property, int depth)
{
Dbg.Assert(source != null, "caller should validate the parameter");
bool sourceHandled = false;
PSObject moSource = source as PSObject;
if (moSource != null && !moSource.immediateBaseObjectIsEmpty)
{
//Check if baseObject is primitive known type
object baseObject = moSource.ImmediateBaseObject;
TypeSerializationInfo pktInfo = KnownTypes.GetTypeSerializationInfo(baseObject.GetType());
if (pktInfo != null)
{
WriteOnePrimitiveKnownType(_writer, property, baseObject, pktInfo);
sourceHandled = true;
}
}
return(sourceHandled);
}
private void WritePrimitiveTypePSObjectWithNotes(PSObject source, object primitive, TypeSerializationInfo pktInfo, string property, int depth)
{
this.WriteStartOfPSObject(source, property, source.ToStringFromDeserialization != null);
if (pktInfo != null)
{
this.WriteOnePrimitiveKnownType(this._writer, null, primitive, pktInfo);
}
PSMemberInfoCollection <PSMemberInfo> instanceMembers = source.InstanceMembers;
if (instanceMembers != null)
{
this.WriteMemberInfoCollection(instanceMembers, depth, true);
}
this._writer.WriteEndElement();
}
private void WriteObjectString(XmlWriter writer, string property, object source, TypeSerializationInfo entry)
{
if (property != null)
{
WriteStartElement(writer, "Property");
WriteAttribute(writer, "Name", property.ToString());
}
else if (this.firstcall)
{
WriteStartElement(writer, "Object");
this.firstcall = false;
}
else
{
WriteStartElement(writer, "Property");
}
if (!this._notypeinformation)
{
WriteAttribute(writer, "Type", source.GetType().ToString());
}
writer.WriteString(source.ToString());
writer.WriteEndElement();
}
private void WriteOnePrimitiveKnownType(XmlWriter writer, string property, object source, TypeSerializationInfo entry)
{
this.WriteObjectString(writer, property, source, entry);
}
private void WriteObjectString(XmlWriter writer, string property, object source, TypeSerializationInfo entry)
{
if (property != null)
{
WriteStartElement(writer, "Property");
WriteAttribute(writer, "Name", property.ToString());
}
else if (this.firstcall)
{
WriteStartElement(writer, "Object");
this.firstcall = false;
}
else
{
WriteStartElement(writer, "Property");
}
if (!this._notypeinformation)
{
WriteAttribute(writer, "Type", source.GetType().ToString());
}
writer.WriteString(source.ToString());
writer.WriteEndElement();
}
/// <summary>
/// Serializes an PSObject whose baseobject is of primitive type
/// and which has notes.
/// </summary>
/// <param name="source">
/// source from which notes are written
/// </param>
/// <param name="primitive">
/// primitive object which is written as base object. In most cases it
/// is same source.ImmediateBaseObject. When PSObject is serialized as string,
/// it can be different. <see cref="HandlePSObjectAsString"/> for more info.
/// </param>
/// <param name="pktInfo">
/// TypeSerializationInfo for the primitive.
/// </param>
/// <param name="property"></param>
/// <param name="depth"></param>
private void WritePrimitiveTypePSObjectWithNotes(
PSObject source,
object primitive,
TypeSerializationInfo pktInfo,
string property,
int depth)
{
Dbg.Assert(source != null, "caller should validate the parameter");
//Write start of PSObject. Since baseobject is primitive known
//type, we do not need TypeName information.
WriteStartOfPSObject(source, property, source.ToStringFromDeserialization != null);
if (pktInfo != null)
{
WriteOnePrimitiveKnownType(_writer, null, primitive, pktInfo);
}
//Serialize instanceMembers
PSMemberInfoCollection<PSMemberInfo> instanceMembers = source.InstanceMembers;
if (instanceMembers != null)
{
WriteMemberInfoCollection(instanceMembers, depth, true);
}
_writer.WriteEndElement();
}
private void WriteObjectString(
XmlWriter writer, string property, object source, TypeSerializationInfo entry)
{
if (property != null)
{
WriteStartElement(writer, CustomSerializationStrings.Properties);
WriteAttribute(writer, CustomSerializationStrings.NameAttribute, property.ToString());
}
else
{
if (_firstcall)
{
WriteStartElement(writer, CustomSerializationStrings.PSObjectTag);
_firstcall = false;
}
else
{
WriteStartElement(writer, CustomSerializationStrings.Properties);
}
}
if (!_notypeinformation)
WriteAttribute(writer, CustomSerializationStrings.TypeAttribute, source.GetType().ToString());
writer.WriteString(source.ToString());
writer.WriteEndElement();
}
private object ReadPrimaryKnownType(TypeSerializationInfo pktInfo)
{
object obj2 = pktInfo.Deserializer(this);
this._reader.MoveToContent();
return obj2;
}
/// <summary>
/// Writes an item or property in Monad namespace.
/// </summary>
/// <param name="writer">The XmlWriter stream to which the object is serialized.</param>
/// <param name="property">name of property. Pass null for item</param>
/// <param name="source">object to be written</param>
/// <param name="entry">serialization information about source</param>
private void WriteOnePrimitiveKnownType(
XmlWriter writer, string property, object source, TypeSerializationInfo entry)
{
WriteObjectString(writer, property, source, entry);
}
private void WritePrimitiveTypePSObjectWithNotes(PSObject source, object primitive, TypeSerializationInfo pktInfo, string property, int depth)
{
this.WriteStartOfPSObject(source, property, source.ToStringFromDeserialization != null);
if (pktInfo != null)
{
this.WriteOnePrimitiveKnownType(this._writer, null, primitive, pktInfo);
}
PSMemberInfoCollection<PSMemberInfo> instanceMembers = source.InstanceMembers;
if (instanceMembers != null)
{
this.WriteMemberInfoCollection(instanceMembers, depth, true);
}
this._writer.WriteEndElement();
}