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); }