/// <summary>
        /// Retrieves all the members available in the object.
        /// The adapter implementation is encouraged to cache all properties/methods available
        /// in the first call to GetMember and GetMembers so that subsequent
        /// calls can use the cache.
        /// In the case of the .NET adapter that would be a cache from the .NET type to
        /// the public properties and fields available in that type.
        /// In the case of the DirectoryEntry adapter, this could be a cache of the objectClass
        /// to the properties available in it.
        /// </summary>
        /// <param name="obj">Object to get all the member information from.</param>
        /// <returns>All members in obj.</returns>
        protected override PSMemberInfoInternalCollection <T> GetMembers <T>(object obj)
        {
            // obj should never be null
            Diagnostics.Assert(obj != null, "Input object is null");

            ManagementBaseObject wmiObject = (ManagementBaseObject)obj;
            PSMemberInfoInternalCollection <T> returnValue = new PSMemberInfoInternalCollection <T>();

            AddAllProperties <T>(wmiObject, returnValue);
            AddAllMethods <T>(wmiObject, returnValue);
            return(returnValue);
        }
示例#2
0
        protected override void DoAddAllProperties <T>(object obj, PSMemberInfoInternalCollection <T> members)
        {
            DataRow row = (DataRow)obj;

            if ((row.Table != null) && (row.Table.Columns != null))
            {
                foreach (DataColumn column in row.Table.Columns)
                {
                    members.Add(new PSProperty(column.ColumnName, this, obj, column.ColumnName) as T);
                }
            }
        }
示例#3
0
 public PSMemberSet(string name)
 {
     this.inheritMembers = true;
     if (string.IsNullOrEmpty(name))
     {
         throw PSTraceSource.NewArgumentException("name");
     }
     base.name            = name;
     this.internalMembers = new PSMemberInfoInternalCollection <PSMemberInfo>();
     this.members         = new PSMemberInfoIntegratingCollection <PSMemberInfo>(this, emptyMemberCollection);
     this.properties      = new PSMemberInfoIntegratingCollection <PSPropertyInfo>(this, emptyPropertyCollection);
     this.methods         = new PSMemberInfoIntegratingCollection <PSMethodInfo>(this, emptyMethodCollection);
 }
示例#4
0
        /// <summary>
        /// Serializes properties of PSObject.
        /// </summary>
        private void WritePSObjectProperties(PSObject source, int depth)
        {
            Dbg.Assert(source != null, "caller should validate the information");

            depth = GetDepthOfSerialization(source, depth);

            //Depth available for each property is one less
            --depth;
            Dbg.Assert(depth >= 0, "depth should be greater or equal to zero");
            if (source.GetSerializationMethod(null) == SerializationMethod.SpecificProperties)
            {
                PSMemberInfoInternalCollection <PSPropertyInfo> specificProperties = new PSMemberInfoInternalCollection <PSPropertyInfo>();
                foreach (string propertyName in source.GetSpecificPropertiesToSerialize(null))
                {
                    PSPropertyInfo property = source.Properties[propertyName];
                    if (property != null)
                    {
                        specificProperties.Add(property);
                    }
                }

                SerializeProperties(specificProperties, CustomSerializationStrings.Properties, depth);
                return;
            }

            foreach (PSPropertyInfo prop in source.Properties)
            {
                Dbg.Assert(prop != null, "propertyCollection should only have member of type PSProperty");
                object value = AutomationNull.Value;
                //PSObject throws GetValueException if it cannot
                //get value for a property.
                try
                {
                    value = prop.Value;
                }
                catch (GetValueException)
                {
                    WritePropertyWithNullValue(_writer, prop, depth);
                    continue;
                }
                //Write the property
                if (value == null)
                {
                    WritePropertyWithNullValue(_writer, prop, depth);
                }
                else
                {
                    WriteOneObject(value, prop.Name, depth);
                }
            }
        }
示例#5
0
 protected override void AddAllMethods <T>(ManagementBaseObject wmiObject, PSMemberInfoInternalCollection <T> members)
 {
     if (typeof(T).IsAssignableFrom(typeof(PSMethod)))
     {
         foreach (BaseWMIAdapter.WMIMethodCacheEntry entry in BaseWMIAdapter.GetInstanceMethodTable(wmiObject, false).memberCollection)
         {
             if (members[entry.Name] == null)
             {
                 Adapter.tracer.WriteLine("Adding method {0}", new object[] { entry.Name });
                 members.Add(new PSMethod(entry.Name, this, wmiObject, entry) as T);
             }
         }
     }
 }
示例#6
0
        protected override PSMemberInfoInternalCollection <T> GetMembers <T>(
            object obj)
        {
            PSMemberInfoInternalCollection <T> internalCollection = new PSMemberInfoInternalCollection <T>();

            foreach (PSMemberInfo member1 in ((PSObject)obj).Members)
            {
                if (member1 is T member)
                {
                    internalCollection.Add(member);
                }
            }
            return(internalCollection);
        }
示例#7
0
        protected override void AddAllProperties <T>(ManagementBaseObject wmiObject,
                                                     PSMemberInfoInternalCollection <T> members)
        {
            // Add System properties
            base.AddAllProperties(wmiObject, members);

            if (wmiObject.Properties != null)
            {
                foreach (PropertyData property in wmiObject.Properties)
                {
                    members.Add(new PSProperty(property.Name, this, wmiObject, property) as T);
                }
            }
        }
示例#8
0
        protected override PSMemberInfoInternalCollection <T> GetMembers <T>(object obj)
        {
            PSMemberInfoInternalCollection <T> internals = new PSMemberInfoInternalCollection <T>();

            foreach (PSMemberInfo info in ((PSMemberSet)obj).Members)
            {
                T member = info as T;
                if (member != null)
                {
                    internals.Add(member);
                }
            }
            return(internals);
        }
示例#9
0
        protected override void DoAddAllProperties <T>(
            object obj,
            PSMemberInfoInternalCollection <T> members)
        {
            DataRow dataRow = (DataRow)obj;

            if (dataRow.Table == null || dataRow.Table.Columns == null)
            {
                return;
            }
            foreach (DataColumn column in (InternalDataCollectionBase)dataRow.Table.Columns)
            {
                members.Add(new PSProperty(column.ColumnName, (Adapter)this, obj, (object)column.ColumnName) as T);
            }
        }
        private PSMemberInfoInternalCollection <T> GetInternalMembers(
            MshMemberMatchOptions matchOptions)
        {
            PSMemberInfoInternalCollection <T> internalCollection = new PSMemberInfoInternalCollection <T>();

            foreach (T obj in (PSMemberInfoCollection <T>) this)
            {
                PSMemberInfo psMemberInfo = (PSMemberInfo)obj;
                if (psMemberInfo.MatchesOptions(matchOptions) && psMemberInfo is T member)
                {
                    internalCollection.Add(member);
                }
            }
            return(internalCollection);
        }
示例#11
0
        /// <summary>
        /// Retrieves all the properties available in the object.
        /// </summary>
        /// <param name="obj">object to get all the property information from</param>
        /// <param name="members">collection where the members will be added</param>
        protected override void DoAddAllProperties <T>(object obj, PSMemberInfoInternalCollection <T> members)
        {
            DataRow dataRow = (DataRow)obj;

            if (dataRow.Table == null || dataRow.Table.Columns == null)
            {
                return;
            }

            foreach (DataColumn property in dataRow.Table.Columns)
            {
                members.Add(new PSProperty(property.ColumnName, this, obj, property.ColumnName) as T);
            }

            return;
        }
        private PSMemberInfoInternalCollection <T> GetInternalMembers(MshMemberMatchOptions matchOptions)
        {
            PSMemberInfoInternalCollection <T> internals = new PSMemberInfoInternalCollection <T>();

            lock (this.members)
            {
                foreach (T local in this.members.Values.OfType <T>())
                {
                    if (local.MatchesOptions(matchOptions))
                    {
                        internals.Add(local);
                    }
                }
            }
            return(internals);
        }
示例#13
0
 internal PSMemberSet(string name, PSObject mshObject)
 {
     this.inheritMembers = true;
     if (string.IsNullOrEmpty(name))
     {
         throw PSTraceSource.NewArgumentException("name");
     }
     base.name = name;
     if (mshObject == null)
     {
         throw PSTraceSource.NewArgumentNullException("mshObject");
     }
     this.constructorPSObject = mshObject;
     this.internalMembers     = mshObject.InstanceMembers;
     this.members             = new PSMemberInfoIntegratingCollection <PSMemberInfo>(this, typeMemberCollection);
     this.properties          = new PSMemberInfoIntegratingCollection <PSPropertyInfo>(this, typePropertyCollection);
     this.methods             = new PSMemberInfoIntegratingCollection <PSMethodInfo>(this, typeMethodCollection);
 }
示例#14
0
 protected override PSMemberInfoInternalCollection <T> GetMembers <T>(
     object obj)
 {
     using (ComAdapter.tracer.TraceMethod())
     {
         ComTypeInfo typeInfo = this.GetTypeInfo();
         PSMemberInfoInternalCollection <T> internalCollection = new PSMemberInfoInternalCollection <T>();
         if (typeInfo != null)
         {
             bool flag1 = typeof(T).IsAssignableFrom(typeof(PSProperty));
             bool flag2 = typeof(T).IsAssignableFrom(typeof(PSParameterizedProperty));
             if (flag1 || flag2)
             {
                 foreach (ComProperty comProperty in typeInfo.Properties.Values)
                 {
                     if (comProperty.IsParameterized)
                     {
                         if (flag2)
                         {
                             internalCollection.Add(new PSParameterizedProperty(comProperty.Name, (Adapter)this, obj, (object)comProperty) as T);
                         }
                     }
                     else if (flag1)
                     {
                         internalCollection.Add(new PSProperty(comProperty.Name, (Adapter)this, obj, (object)comProperty) as T);
                     }
                 }
             }
             if (typeof(T).IsAssignableFrom(typeof(PSMethod)))
             {
                 foreach (ComMethod comMethod in typeInfo.Methods.Values)
                 {
                     PSMethod psMethod = new PSMethod(comMethod.Name, (Adapter)this, obj, (object)comMethod);
                     if (!internalCollection.hashedMembers.Contains((object)comMethod.Name))
                     {
                         internalCollection.Add(psMethod as T);
                     }
                 }
             }
         }
         return(internalCollection);
     }
 }
 private void WritePSObjectProperties(PSObject source, int depth)
 {
     depth = GetDepthOfSerialization(source, depth);
     depth--;
     if (source.GetSerializationMethod(null) == SerializationMethod.SpecificProperties)
     {
         PSMemberInfoInternalCollection <PSPropertyInfo> propertyCollection = new PSMemberInfoInternalCollection <PSPropertyInfo>();
         foreach (string str in source.GetSpecificPropertiesToSerialize(null))
         {
             PSPropertyInfo member = source.Properties[str];
             if (member != null)
             {
                 propertyCollection.Add(member);
             }
         }
         this.SerializeProperties(propertyCollection, "Property", depth);
     }
     else
     {
         foreach (PSPropertyInfo info2 in source.Properties)
         {
             object obj2 = AutomationNull.Value;
             try
             {
                 obj2 = info2.Value;
             }
             catch (GetValueException)
             {
                 this.WritePropertyWithNullValue(this._writer, info2, depth);
                 continue;
             }
             if (obj2 == null)
             {
                 this.WritePropertyWithNullValue(this._writer, info2, depth);
             }
             else
             {
                 this.WriteOneObject(obj2, info2.Name, depth);
             }
         }
     }
 }
示例#16
0
 public PSMemberSet(string name, IEnumerable <PSMemberInfo> members)
 {
     this.name = !string.IsNullOrEmpty(name) ? name : throw PSMemberSet.tracer.NewArgumentException(nameof(name));
     if (members == null)
     {
         throw PSMemberSet.tracer.NewArgumentNullException(nameof(members));
     }
     this.internalMembers = new PSMemberInfoInternalCollection <PSMemberInfo>();
     foreach (PSMemberInfo member in members)
     {
         if (member == null)
         {
             throw PSMemberSet.tracer.NewArgumentNullException(nameof(members));
         }
         this.internalMembers.Add(member.Copy());
     }
     this.members    = new PSMemberInfoIntegratingCollection <PSMemberInfo>((object)this, PSMemberSet.emptyMemberCollection);
     this.properties = new PSMemberInfoIntegratingCollection <PSPropertyInfo>((object)this, PSMemberSet.emptyPropertyCollection);
     this.methods    = new PSMemberInfoIntegratingCollection <PSMethodInfo>((object)this, PSMemberSet.emptyMethodCollection);
 }
示例#17
0
 internal Enumerator(PSMemberInfoIntegratingCollection <S> integratingCollection)
 {
     using (PSObject.memberResolution.TraceScope("Enumeration Start", new object[0]))
     {
         this.currentIndex = -1;
         this.current      = default(S);
         this.allMembers   = integratingCollection.GetIntegratedMembers(MshMemberMatchOptions.None);
         if (integratingCollection.mshOwner != null)
         {
             integratingCollection.GenerateAllReservedMembers();
             PSObject.memberResolution.WriteLine("Enumerating PSObject with type \"{0}\".", new object[] { integratingCollection.mshOwner.ImmediateBaseObject.GetType().FullName });
             PSObject.memberResolution.WriteLine("PSObject instance members: {0}", new object[] { this.allMembers.VisibleCount });
         }
         else
         {
             PSObject.memberResolution.WriteLine("Enumerating PSMemberSet \"{0}\".", new object[] { integratingCollection.memberSetOwner.Name });
             PSObject.memberResolution.WriteLine("MemberSet instance members: {0}", new object[] { this.allMembers.VisibleCount });
         }
     }
 }
示例#18
0
 private PSMemberInfoInternalCollection<PSMemberInfo> GetInternalMembersFromAdapted()
 {
     PSMemberInfoInternalCollection<PSMemberInfo> internals = new PSMemberInfoInternalCollection<PSMemberInfo>();
     if (this.psObject.isDeserialized)
     {
         if (this.psObject.adaptedMembers != null)
         {
             foreach (PSMemberInfo info in this.psObject.adaptedMembers)
             {
                 internals.Add(info.Copy());
             }
         }
         return internals;
     }
     foreach (PSMemberInfo info2 in this.psObject.InternalAdapter.BaseGetMembers<PSMemberInfo>(this.psObject.ImmediateBaseObject))
     {
         internals.Add(info2.Copy());
     }
     return internals;
 }
 private void SerializeProperties(PSMemberInfoInternalCollection <PSPropertyInfo> propertyCollection, string name, int depth)
 {
     if (propertyCollection.Count != 0)
     {
         foreach (PSMemberInfo info in propertyCollection)
         {
             PSPropertyInfo info2  = info as PSPropertyInfo;
             object         source = AutomationNull.Value;
             try
             {
                 source = info2.Value;
             }
             catch (GetValueException)
             {
                 continue;
             }
             this.WriteOneObject(source, info2.Name, depth);
         }
     }
 }
示例#20
0
        /// <summary>
        /// Retrieves all the members available in the object.
        /// The adapter implementation is encouraged to cache all properties/methods available
        /// in the first call to GetMember and GetMembers so that subsequent
        /// calls can use the cache.
        /// In the case of the .NET adapter that would be a cache from the .NET type to
        /// the public properties and fields available in that type.
        /// In the case of the DirectoryEntry adapter, this could be a cache of the objectClass
        /// to the properties available in it.
        /// </summary>
        /// <param name="obj">object to get all the member information from</param>
        /// <returns>all members in obj</returns>
        protected override PSMemberInfoInternalCollection <T> GetMembers <T>(object obj)
        {
            PSMemberInfoInternalCollection <T> collection = new PSMemberInfoInternalCollection <T>();

            bool lookingForProperties = typeof(T).IsAssignableFrom(typeof(PSProperty));
            bool lookingForParameterizedProperties = typeof(T).IsAssignableFrom(typeof(PSParameterizedProperty));

            if (lookingForProperties || lookingForParameterizedProperties)
            {
                foreach (ComProperty prop in _comTypeInfo.Properties.Values)
                {
                    if (prop.IsParameterized)
                    {
                        if (lookingForParameterizedProperties)
                        {
                            collection.Add(new PSParameterizedProperty(prop.Name, this, obj, prop) as T);
                        }
                    }
                    else if (lookingForProperties)
                    {
                        collection.Add(new PSProperty(prop.Name, this, obj, prop) as T);
                    }
                }
            }

            bool lookingForMethods = typeof(T).IsAssignableFrom(typeof(PSMethod));

            if (lookingForMethods)
            {
                foreach (ComMethod method in _comTypeInfo.Methods.Values)
                {
                    if (collection[method.Name] == null)
                    {
                        PSMethod mshmethod = new PSMethod(method.Name, this, obj, method);
                        collection.Add(mshmethod as T);
                    }
                }
            }

            return(collection);
        }
示例#21
0
        protected override void DoAddAllProperties <T>(object obj, PSMemberInfoInternalCollection <T> members)
        {
            System.Xml.XmlNode node = (System.Xml.XmlNode)obj;
            Dictionary <string, List <System.Xml.XmlNode> > dictionary = new Dictionary <string, List <System.Xml.XmlNode> >(StringComparer.OrdinalIgnoreCase);

            if (node.Attributes != null)
            {
                foreach (System.Xml.XmlNode node2 in node.Attributes)
                {
                    List <System.Xml.XmlNode> list;
                    if (!dictionary.TryGetValue(node2.LocalName, out list))
                    {
                        list = new List <System.Xml.XmlNode>();
                        dictionary[node2.LocalName] = list;
                    }
                    list.Add(node2);
                }
            }
            if (node.ChildNodes != null)
            {
                foreach (System.Xml.XmlNode node3 in node.ChildNodes)
                {
                    if (!(node3 is XmlWhitespace))
                    {
                        List <System.Xml.XmlNode> list2;
                        if (!dictionary.TryGetValue(node3.LocalName, out list2))
                        {
                            list2 = new List <System.Xml.XmlNode>();
                            dictionary[node3.LocalName] = list2;
                        }
                        list2.Add(node3);
                    }
                }
            }
            foreach (KeyValuePair <string, List <System.Xml.XmlNode> > pair in dictionary)
            {
                members.Add(new PSProperty(pair.Key, this, obj, pair.Value.ToArray()) as T);
            }
        }
示例#22
0
        protected override void DoAddAllProperties <T>(
            object obj,
            PSMemberInfoInternalCollection <T> members)
        {
            XmlNode xmlNode = (XmlNode)obj;
            Dictionary <string, List <XmlNode> > dictionary = new Dictionary <string, List <XmlNode> >((IEqualityComparer <string>)StringComparer.OrdinalIgnoreCase);

            if (xmlNode.Attributes != null)
            {
                foreach (XmlNode attribute in (XmlNamedNodeMap)xmlNode.Attributes)
                {
                    List <XmlNode> xmlNodeList;
                    if (!dictionary.TryGetValue(attribute.LocalName, out xmlNodeList))
                    {
                        xmlNodeList = new List <XmlNode>();
                        dictionary[attribute.LocalName] = xmlNodeList;
                    }
                    xmlNodeList.Add(attribute);
                }
            }
            if (xmlNode.ChildNodes != null)
            {
                foreach (XmlNode childNode in xmlNode.ChildNodes)
                {
                    List <XmlNode> xmlNodeList;
                    if (!dictionary.TryGetValue(childNode.LocalName, out xmlNodeList))
                    {
                        xmlNodeList = new List <XmlNode>();
                        dictionary[childNode.LocalName] = xmlNodeList;
                    }
                    xmlNodeList.Add(childNode);
                }
            }
            foreach (KeyValuePair <string, List <XmlNode> > keyValuePair in dictionary)
            {
                members.Add(new PSProperty(keyValuePair.Key, (Adapter)this, obj, (object)keyValuePair.Value.ToArray()) as T);
            }
        }
示例#23
0
        protected override void DoAddAllProperties <T>(object obj, PSMemberInfoInternalCollection <T> members)
        {
            Collection <PSAdaptedProperty> properties = null;

            try
            {
                properties = this.externalAdapter.GetProperties(obj);
            }
            catch (Exception exception)
            {
                CommandProcessorBase.CheckForSevereException(exception);
                throw new ExtendedTypeSystemException("PSPropertyAdapter.GetProperties", exception, ExtendedTypeSystem.GetProperties, new object[] { obj.ToString() });
            }
            if (properties == null)
            {
                throw new ExtendedTypeSystemException("PSPropertyAdapter.NullReturnValueError", null, ExtendedTypeSystem.NullReturnValueError, new object[] { "PSPropertyAdapter.GetProperties" });
            }
            foreach (PSAdaptedProperty property in properties)
            {
                this.InitializeProperty(property, obj);
                members.Add(property as T);
            }
        }
示例#24
0
        /// <summary>
        /// Adds method information of the ManagementObject. Only instance methods are added for
        /// a ManagementObject.
        /// </summary>
        /// <typeparam name="T">PSMemberInfo</typeparam>
        /// <param name="wmiObject">Object for which the members need to be retrieved.</param>
        /// <param name="members">Method information is added to this.</param>
        protected override void AddAllMethods <T>(ManagementBaseObject wmiObject,
                                                  PSMemberInfoInternalCollection <T> members)
        {
            Diagnostics.Assert((wmiObject != null) && (members != null),
                               "Input arguments should not be null.");

            if (!typeof(T).IsAssignableFrom(typeof(PSMethod)))
            {
                return;
            }

            CacheTable table;

            table = GetInstanceMethodTable(wmiObject, false);

            foreach (WMIMethodCacheEntry methodEntry in table.memberCollection)
            {
                if (members[methodEntry.Name] == null)
                {
                    tracer.WriteLine("Adding method {0}", methodEntry.Name);
                    members.Add(new PSMethod(methodEntry.Name, this, wmiObject, methodEntry) as T);
                }
            }
        }
示例#25
0
        protected override PSMemberInfoInternalCollection <T> GetMembers <T>(object obj)
        {
            PSMemberInfoInternalCollection <T> internals = new PSMemberInfoInternalCollection <T>();
            bool flag  = typeof(T).IsAssignableFrom(typeof(PSProperty));
            bool flag2 = typeof(T).IsAssignableFrom(typeof(PSParameterizedProperty));

            if (flag || flag2)
            {
                foreach (ComProperty property in this._comTypeInfo.Properties.Values)
                {
                    if (property.IsParameterized)
                    {
                        if (flag2)
                        {
                            internals.Add(new PSParameterizedProperty(property.Name, this, obj, property) as T);
                        }
                    }
                    else if (flag)
                    {
                        internals.Add(new PSProperty(property.Name, this, obj, property) as T);
                    }
                }
            }
            if (typeof(T).IsAssignableFrom(typeof(PSMethod)))
            {
                foreach (ComMethod method in this._comTypeInfo.Methods.Values)
                {
                    if (internals[method.Name] == null)
                    {
                        PSMethod method2 = new PSMethod(method.Name, this, obj, method);
                        internals.Add(method2 as T);
                    }
                }
            }
            return(internals);
        }
示例#26
0
 /// <summary>
 /// Adds method information of the ManagementObject. This is done by accessing
 /// the ManagementClass corresponding to this ManagementObject. All the method
 /// information is cached for a particular ManagementObject.
 /// </summary>
 /// <typeparam name="T">PSMemberInfo</typeparam>
 /// <param name="wmiObject">Object for which the members need to be retrieved.</param>
 /// <param name="members">Method information is added to this.</param>
 protected abstract void AddAllMethods <T>(ManagementBaseObject wmiObject,
                                           PSMemberInfoInternalCollection <T> members) where T : PSMemberInfo;
示例#27
0
 protected abstract void DoAddAllProperties <T>(object obj, PSMemberInfoInternalCollection <T> members) where T : PSMemberInfo;
        private void HandleComplexTypePSObject
        (
            object source,
            string property,
            int depth,
            out CimInstance result
        )
        {
            List <CimInstance> listOfCimInstancesProperties = null;

            Dbg.Assert(source != null, "caller should validate the parameter");
            PSObject mshSource = PSObject.AsPSObject(source);

            // Figure out what kind of object we are dealing with
            bool isErrorRecord         = false;
            bool isInformationalRecord = false;
            bool isEnum     = false;
            bool isPSObject = false;

            //TODO, insivara : To be implemented
            //bool isCimInstance = false;

            if (!mshSource.immediateBaseObjectIsEmpty)
            {
                ErrorRecord errorRecord = mshSource.ImmediateBaseObject as ErrorRecord;
                if (errorRecord == null)
                {
                    InformationalRecord informationalRecord = mshSource.ImmediateBaseObject as InformationalRecord;
                    if (informationalRecord == null)
                    {
                        isEnum     = mshSource.ImmediateBaseObject is Enum;
                        isPSObject = mshSource.ImmediateBaseObject is PSObject;
                    }
                    else
                    {
                        informationalRecord.ToPSObjectForRemoting(mshSource);
                        isInformationalRecord = true;
                    }
                }
                else
                {
                    errorRecord.ToPSObjectForRemoting(mshSource);
                    isErrorRecord = true;
                }
            }

            bool writeToString = true;

            if (mshSource.ToStringFromDeserialization == null)
            // continue to write ToString from deserialized objects, but...
            {
                if (mshSource.immediateBaseObjectIsEmpty) // ... don't write ToString for property bags
                {
                    writeToString = false;
                }
            }

            // This will create a CimInstance for PS_Object and populate the typenames.
            result = CreateCimInstanceForPSObject(cimClassName: "PS_Object",
                                                  psObj: mshSource,
                                                  writeToString: writeToString);

            PSMemberInfoInternalCollection <PSPropertyInfo> specificPropertiesToSerialize =
                SerializationUtilities.GetSpecificPropertiesToSerialize(mshSource, AllPropertiesCollection, _typeTable);

            if (isEnum)
            {
                CimInstance enumCimInstance = CreateCimInstanceForEnum(mshSource, depth, property != null);
                CimProperty p = CimProperty.Create("Value", enumCimInstance,
                                                   Microsoft.Management.Infrastructure.CimType.Reference,
                                                   Microsoft.Management.Infrastructure.CimFlags.Property);
                result.CimInstanceProperties.Add(p);
            }
            else if (isPSObject)
            {
                CimInstance psObjectCimInstance;
                CreateCimInstanceForOneObject(mshSource.ImmediateBaseObject, property, depth, out psObjectCimInstance);
                CimProperty valueProperty = CimProperty.Create("Value", psObjectCimInstance,
                                                               Microsoft.Management.Infrastructure.CimType.Reference,
                                                               Microsoft.Management.Infrastructure.CimFlags.Property);
                result.CimInstanceProperties.Add(valueProperty);
            }
            else if (isErrorRecord || isInformationalRecord)
            {
                // nothing to do
            }
            else
            {
                CreateCimInstanceForPSObjectProperties(mshSource, depth, specificPropertiesToSerialize, out listOfCimInstancesProperties);
            }

            //TODO, insivara : Implement serialization of CimInstance
            //if (isCimInstance)
            //{
            //    CimInstance cimInstance = mshSource.ImmediateBaseObject as CimInstance;
            //    PrepareCimInstanceForSerialization(mshSource, cimInstance);
            //}

            //TODO, insivara : ExtendedProperties implementation will be done in a subsequent checkin
            //SerializeExtendedProperties(mshSource, depth, specificPropertiesToSerialize, out listOfCimInstancesExtendedProperties);

            if (listOfCimInstancesProperties != null && listOfCimInstancesProperties.Count > 0)
            {
                CimInstance[] referenceArray = listOfCimInstancesProperties.ToArray();
                CimProperty   properties     = CimProperty.Create("Properties", referenceArray,
                                                                  Microsoft.Management.Infrastructure.CimType.ReferenceArray,
                                                                  Microsoft.Management.Infrastructure.CimFlags.Property);
                result.CimInstanceProperties.Add(properties);
            }
        }
示例#29
0
 private PSMemberInfoInternalCollection <T> GetIntegratedMembers(MshMemberMatchOptions matchOptions)
 {
     using (PSObject.memberResolution.TraceScope("Generating the total list of members", new object[0]))
     {
         object mshOwner;
         PSMemberInfoInternalCollection <T> internals = new PSMemberInfoInternalCollection <T>();
         if (this.mshOwner != null)
         {
             mshOwner = this.mshOwner;
             foreach (PSMemberInfo info in this.mshOwner.InstanceMembers)
             {
                 if (info.MatchesOptions(matchOptions))
                 {
                     T member = info as T;
                     if (member != null)
                     {
                         internals.Add(member);
                     }
                 }
             }
         }
         else
         {
             mshOwner = this.memberSetOwner.instance;
             foreach (PSMemberInfo info2 in this.memberSetOwner.InternalMembers)
             {
                 if (info2.MatchesOptions(matchOptions))
                 {
                     T local2 = info2 as T;
                     if (local2 != null)
                     {
                         info2.ReplicateInstance(mshOwner);
                         internals.Add(local2);
                     }
                 }
             }
         }
         if (mshOwner != null)
         {
             mshOwner = PSObject.AsPSObject(mshOwner);
             foreach (CollectionEntry <T> entry in this.collections)
             {
                 foreach (T local3 in entry.GetMembers((PSObject)mshOwner))
                 {
                     PSMemberInfo info3 = internals[local3.Name];
                     if (info3 != null)
                     {
                         PSObject.memberResolution.WriteLine("Member \"{0}\" of type \"{1}\" has been ignored because a member with the same name and type \"{2}\" is already present.", new object[] { local3.Name, local3.MemberType, info3.MemberType });
                     }
                     else if (!local3.MatchesOptions(matchOptions))
                     {
                         PSObject.memberResolution.WriteLine("Skipping hidden member \"{0}\".", new object[] { local3.Name });
                     }
                     else
                     {
                         T local4;
                         if (entry.ShouldCloneWhenReturning)
                         {
                             local4 = (T)local3.Copy();
                         }
                         else
                         {
                             local4 = local3;
                         }
                         if (entry.ShouldReplicateWhenReturning)
                         {
                             local4.ReplicateInstance(mshOwner);
                         }
                         internals.Add(local4);
                     }
                 }
             }
         }
         return(internals);
     }
 }
示例#30
0
 internal ReadOnlyPSMemberInfoCollection(PSMemberInfoInternalCollection <T> members) => this.members = members != null ? members : throw ReadOnlyPSMemberInfoCollection <T> .tracer.NewArgumentNullException(nameof(members));