internal void AddToTypesXmlCache(T member, bool preValidated)
{
if (member == null)
{
throw PSTraceSource.NewArgumentNullException("member");
}
if (!preValidated && PSMemberInfoCollection <T> .IsReservedName(member.Name))
{
throw new ExtendedTypeSystemException("PSObjectMembersMembersAddReservedName", null, ExtendedTypeSystem.ReservedMemberName, new object[] { member.Name });
}
PSMemberInfo info = member.Copy();
if (this.mshOwner != null)
{
if (!preValidated)
{
TypeTable typeTable = this.mshOwner.GetTypeTable();
if ((typeTable != null) && (typeTable.GetMembers <T>(this.mshOwner.InternalTypeNames)[member.Name] != null))
{
throw new ExtendedTypeSystemException("AlreadyPresentInTypesXml", null, ExtendedTypeSystem.MemberAlreadyPresentFromTypesXml, new object[] { member.Name });
}
}
info.ReplicateInstance(this.mshOwner);
this.mshOwner.InstanceMembers.Add(info, preValidated);
PSGetMemberBinder.SetHasInstanceMember(info.Name);
PSVariableAssignmentBinder.NoteTypeHasInstanceMemberOrTypeName(PSObject.Base(this.mshOwner).GetType());
}
else
{
this.memberSetOwner.InternalMembers.Add(info, preValidated);
}
}
public override void Remove(string name)
{
if (string.IsNullOrEmpty(name))
{
throw PSMemberInfoIntegratingCollection <T> .tracer.NewArgumentException(nameof (name));
}
if (this.mshOwner != null)
{
this.mshOwner.InstanceMembers.Remove(name);
}
else
{
if (!this.memberSetOwner.IsInstance)
{
throw new ExtendedTypeSystemException("AddMemberToStaticMemberSet", (Exception)null, "ExtendedTypeSystem", "ChangeStaticMember", new object[1]
{
(object)name
});
}
if (PSMemberInfoCollection <T> .IsReservedName(this.memberSetOwner.Name))
{
throw new ExtendedTypeSystemException("CannotRemoveFromReservedNameMemberset", (Exception)null, "ExtendedTypeSystem", "CannotChangeReservedMember", new object[1]
{
(object)this.memberSetOwner.Name
});
}
this.memberSetOwner.InternalMembers.Remove(name);
}
}
private void WriteMemberInfoCollection(PSMemberInfoCollection <PSMemberInfo> me, int depth, bool writeEnclosingMemberSetElementTag)
{
bool flag = false;
foreach (PSMemberInfo info in me)
{
if (info.ShouldSerialize)
{
PSPropertyInfo info2 = info as PSPropertyInfo;
if (info2 != null)
{
flag = true;
WriteStartElement(this._writer, "Property");
WriteAttribute(this._writer, "Name", info.Name);
if (!this._notypeinformation)
{
WriteAttribute(this._writer, "Type", info.GetType().ToString());
}
this._writer.WriteString(info2.Value.ToString());
}
}
}
if (flag)
{
this._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();
}
public override void Remove(string name)
{
object obj = !string.IsNullOrEmpty(name) ? this.hashedMembers[(object)name] : throw PSMemberInfoInternalCollection <T> .tracer.NewArgumentException(nameof (name));
if (obj == null)
{
return;
}
if (PSMemberInfoCollection <T> .IsReservedName(name))
{
throw new ExtendedTypeSystemException("PSMemberInfoInternalCollectionRemoveReservedName", (Exception)null, "ExtendedTypeSystem", "ReservedMemberName", new object[1]
{
(object)name
});
}
int index1 = ((int?)obj).Value;
if (this.members[index1].IsHidden)
{
--this.countHidden;
}
this.members.RemoveAt(index1);
for (int index2 = index1; index2 < this.members.Count; ++index2)
{
int?hashedMember = (int?)this.hashedMembers[(object)this.members[index2].Name];
this.hashedMembers[(object)this.members[index2].Name] = (object)new int?(hashedMember.Value - 1);
}
this.hashedMembers.Remove((object)name);
}
/// <summary>
/// Serialize member set. This method serializes without writing.
/// enclosing tags and attributes.
/// </summary>
/// <param name="me">
/// Enumerable containing members
/// </param>
/// <param name="depth"></param>
/// <param name="writeEnclosingMemberSetElementTag">
/// if this is true, write an enclosing "<memberset></memberset>" tag.
/// </param>
/// <returns></returns>
private void WriteMemberInfoCollection(
PSMemberInfoCollection <PSMemberInfo> me, int depth, bool writeEnclosingMemberSetElementTag)
{
Dbg.Assert(me != null, "caller should validate the parameter");
foreach (PSMemberInfo info in me)
{
if (!info.ShouldSerialize)
{
continue;
}
PSPropertyInfo property = info as PSPropertyInfo;
if (property == null)
{
continue;
}
WriteStartElement(_writer, CustomSerializationStrings.Properties);
WriteAttribute(_writer, CustomSerializationStrings.NameAttribute, info.Name);
if (!_notypeinformation)
{
WriteAttribute(_writer, CustomSerializationStrings.TypeAttribute, info.GetType().ToString());
}
_writer.WriteString(property.Value.ToString());
_writer.WriteEndElement();
}
}
private void InitProperties()
{
_properties = new PSMemberInfoCollectionImplementation <PSPropertyInfo>(this);
var properties = GetProperties(true);
properties.ForEach(_properties.Add);
properties.ForEach(_members.Add);
}
private void InitMethods()
{
_methods = new PSMemberInfoCollectionImplementation <PSMethodInfo>(this);
var methods = GetMethods(true);
methods.ForEach(_methods.Add);
methods.ForEach(_members.Add);
}
protected void Initialize(object obj)
{
if (obj == null)
{
throw new PSArgumentNullException("Argument \"obj\" is null");
}
_members = new PSMemberInfoCollectionImplementation <PSMemberInfo>(this);
ImmediateBaseObject = obj;
}
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 bool HandleKnownContainerTypes(object source, string property, int depth)
{
ContainerType none = ContainerType.None;
PSObject obj2 = source as PSObject;
IEnumerable enumerable = null;
IDictionary dictionary = null;
if ((obj2 != null) && obj2.immediateBaseObjectIsEmpty)
{
return(false);
}
this.GetKnownContainerTypeInfo((obj2 != null) ? obj2.ImmediateBaseObject : source, out none, out dictionary, out enumerable);
if (none == ContainerType.None)
{
return(false);
}
this.WriteStartOfPSObject((obj2 != null) ? obj2 : PSObject.AsPSObject(source), property, true);
switch (none)
{
case ContainerType.Dictionary:
this.WriteDictionary(dictionary, depth);
break;
case ContainerType.Queue:
case ContainerType.Stack:
case ContainerType.List:
case ContainerType.Enumerable:
this.WriteEnumerable(enumerable, depth);
break;
}
if ((depth != 0) && ((none == ContainerType.Enumerable) || ((obj2 != null) && obj2.isDeserialized)))
{
this.WritePSObjectProperties(PSObject.AsPSObject(source), depth);
}
if (obj2 != null)
{
PSMemberInfoCollection <PSMemberInfo> instanceMembers = obj2.InstanceMembers;
if (instanceMembers != null)
{
this.WriteMemberInfoCollection(instanceMembers, depth, true);
}
}
this._writer.WriteEndElement();
return(true);
}
public override void Remove(string name)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (PSMemberInfoCollection <T> .IsReservedName(name))
{
throw new ExtendedTypeSystemException("PSMemberInfoInternalCollectionRemoveReservedName", null, ExtendedTypeSystem.ReservedMemberName, new object[] { name });
}
lock (this.members)
{
PSMemberInfo info = this.members[name] as PSMemberInfo;
if (info != null)
{
if (info.IsHidden)
{
this.countHidden--;
}
this.members.Remove(name);
}
}
}
public override void Remove(string name)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
if (this.mshOwner != null)
{
this.mshOwner.InstanceMembers.Remove(name);
}
else
{
if (!this.memberSetOwner.IsInstance)
{
throw new ExtendedTypeSystemException("AddMemberToStaticMemberSet", null, ExtendedTypeSystem.ChangeStaticMember, new object[] { name });
}
if (PSMemberInfoCollection <T> .IsReservedName(this.memberSetOwner.Name))
{
throw new ExtendedTypeSystemException("CannotRemoveFromReservedNameMemberset", null, ExtendedTypeSystem.CannotChangeReservedMember, new object[] { this.memberSetOwner.Name });
}
this.memberSetOwner.InternalMembers.Remove(name);
}
}
internal void AddToTypesXmlCache(T member, bool preValidated)
{
if ((object)member == null)
{
throw PSMemberInfoIntegratingCollection <T> .tracer.NewArgumentNullException(nameof (member));
}
if (!preValidated && PSMemberInfoCollection <T> .IsReservedName(member.Name))
{
throw new ExtendedTypeSystemException("PSObjectMembersMembersAddReservedName", (Exception)null, "ExtendedTypeSystem", "ReservedMemberName", new object[1]
{
(object)member.Name
});
}
PSMemberInfo member1 = member.Copy();
if (this.mshOwner != null)
{
if (!preValidated)
{
TypeTable typeTable = this.mshOwner.GetTypeTable();
if (typeTable != null && (object)typeTable.GetMembers <T>(this.mshOwner.InternalTypeNames)[member.Name] != null)
{
throw new ExtendedTypeSystemException("AlreadyPresentInTypesXml", (Exception)null, "ExtendedTypeSystem", "MemberAlreadyPresentFromTypesXml", new object[1]
{
(object)member.Name
});
}
}
member1.ReplicateInstance(this.mshOwner);
this.mshOwner.InstanceMembers.Add(member1, preValidated);
}
else
{
this.memberSetOwner.InternalMembers.Add(member1, preValidated);
}
}
protected void Initialize(object obj)
{
_members = new PSMemberInfoCollectionImplementation <PSMemberInfo>(this);
ImmediateBaseObject = obj;
}
private bool HandleKnownContainerTypes(object source, string property, int depth)
{
Dbg.Assert(source != null, "caller should validate the parameter");
ContainerType ct = ContainerType.None;
PSObject mshSource = source as PSObject;
IEnumerable enumerable = null;
IDictionary dictionary = null;
//If passed in object is PSObject with no baseobject, return false.
if (mshSource != null && mshSource.immediateBaseObjectIsEmpty)
{
return(false);
}
//Check if source (or baseobject in mshSource) is known container type
GetKnownContainerTypeInfo(mshSource != null ? mshSource.ImmediateBaseObject : source, out ct,
out dictionary, out enumerable);
if (ct == ContainerType.None)
{
return(false);
}
WriteStartOfPSObject(mshSource ?? PSObject.AsPSObject(source), property, true);
switch (ct)
{
case ContainerType.Dictionary:
{
WriteDictionary(dictionary, depth);
}
break;
case ContainerType.Stack:
case ContainerType.Queue:
case ContainerType.List:
case ContainerType.Enumerable:
{
WriteEnumerable(enumerable, depth);
}
break;
default:
{
Dbg.Assert(false, "All containers should be handled in the switch");
}
break;
}
//An object which is original enumerable becomes an PSObject
//with arraylist on deserialization. So on roundtrip it will show up
//as List.
//We serialize properties of enumerable and on deserialization mark the object
//as Deserialized. So if object is marked deserialized, we should write properties.
//Note: we do not serialize the properties of IEnumerable if depth is zero.
if (depth != 0 && (ct == ContainerType.Enumerable || (mshSource != null && mshSource.isDeserialized)))
{
//Note:Depth is the depth for serialization of baseObject.
//Depth for serialization of each property is one less.
WritePSObjectProperties(PSObject.AsPSObject(source), depth);
}
//If source is PSObject, serialize notes
if (mshSource != null)
{
//Serialize instanceMembers
PSMemberInfoCollection <PSMemberInfo> instanceMembers = mshSource.InstanceMembers;
if (instanceMembers != null)
{
WriteMemberInfoCollection(instanceMembers, depth, true);
}
}
_writer.WriteEndElement();
return(true);
}
private void InitStaticMembers()
{
_staticMembers = new PSMemberInfoCollectionImplementation <PSMemberInfo>(this);
GetMethods(false).ForEach(_staticMembers.Add);
GetProperties(false).ForEach(_staticMembers.Add);
}
