C# Automation.PSObject类代码示例

 public void ConvertToCanPackAsPSObjectArray()
 {
     var result = LanguagePrimitives.ConvertTo(3, typeof(PSObject[]));
     var expected = new PSObject[] { PSObject.AsPSObject(3) };
     Assert.AreEqual(expected.GetType(), result.GetType());
     Assert.AreEqual(expected, result);
 }

        private Object ConvertToReturnObject(object currentObject)
        {
            List<Object> currentAsArray = currentObject as List<Object>;
            if(currentAsArray != null)
            {
                PSObject[] result = new PSObject[currentAsArray.Count];

                for(int currentIndex = 0; currentIndex < currentAsArray.Count; currentIndex++)
                {
                    result[currentIndex] = (PSObject) ConvertToReturnObject(currentAsArray[currentIndex]);
                }

                return result;
            }

            OrderedDictionary currentAsDictionary = currentObject as OrderedDictionary;
            if (currentAsDictionary != null)
            {
                PSObject result = new PSObject();
                foreach (string key in currentAsDictionary.Keys)
                {
                    result.Properties.Add(new PSNoteProperty(key, ConvertToReturnObject(currentAsDictionary[key])));
                }

                return result;
            }

            return currentObject;
        }

 internal override void Deserialize(PSObject so, FormatObjectDeserializer deserializer)
 {
     base.Deserialize(so, deserializer);
     this.leftIndentation = deserializer.DeserializeIntMemberVariable(so, "leftIndentation");
     this.rightIndentation = deserializer.DeserializeIntMemberVariable(so, "rightIndentation");
     this.firstLine = deserializer.DeserializeIntMemberVariable(so, "firstLine");
 }

 protected override void ProcessRecord()
 {
     base.ProcessRecord();
     if (Globals.authToken != null)
     {
         _serverProxy = new ServerCommandProxy(Globals.ComputerName, Globals.Port, Globals.authToken);
         try
         {
             _serverProxy.AddAdminAccessUser(UserName);
             PSObject returnAddPcutAdminAccessUser = new PSObject();
             returnAddPcutAdminAccessUser.Properties.Add(new PSNoteProperty("Username", UserName));
             returnAddPcutAdminAccessUser.Properties.Add(new PSNoteProperty("AdminAccess", true));
             WriteObject(returnAddPcutAdminAccessUser);
         }
         catch (XmlRpcFaultException fex)
         {
             ErrorRecord errRecord = new ErrorRecord(new Exception(fex.Message, fex.InnerException), fex.FaultString, ErrorCategory.NotSpecified, fex);
             WriteError(errRecord);
         }
     }
     else
     {
         WriteObject("Please run Connect-PcutServer in order to establish connection.");
     }
 }

        /// <summary>
        /// compute the string value of the grouping property
        /// </summary>
        /// <param name="so">object to use to compute the property value</param>
        /// <returns>true if there was an update</returns>
        internal bool UpdateGroupingKeyValue(PSObject so)
        {
            if (_groupingKeyExpression == null)
                return false;

            List<MshExpressionResult> results = _groupingKeyExpression.GetValues(so);

            // if we have more that one match, we have to select the first one
            if (results.Count > 0 && results[0].Exception == null)
            {
                // no exception got thrown, so we can update
                object newValue = results[0].Result;
                object oldValue = _currentGroupingKeyPropertyValue;

                _currentGroupingKeyPropertyValue = newValue;

                // now do the comparison
                bool update = !(IsEqual(_currentGroupingKeyPropertyValue, oldValue) ||
                                IsEqual(oldValue, _currentGroupingKeyPropertyValue));

                if (update && _label == null)
                {
                    _groupingKeyDisplayName = results[0].ResolvedExpression.ToString();
                }
                return update;
            }

            // we had no matches or we could not get the value:
            // NOTICE: we need to do this to avoid starting a new group every time 
            // there is a failure to read the grouping property.
            // For example, for AD, there are objects that throw when trying
            // to read the "distinguishedName" property (used by the brokered property "ParentPath)
            return false;
        }

 internal override void Deserialize(PSObject so, FormatObjectDeserializer deserializer)
 {
     base.Deserialize(so, deserializer);
     this.label = deserializer.DeserializeStringMemberVariable(so, "label");
     this.propertyName = deserializer.DeserializeStringMemberVariable(so, "propertyName");
     this.formatPropertyField = (FormatPropertyField) deserializer.DeserializeMandatoryMemberObject(so, "formatPropertyField");
 }

        internal static List<MshResolvedExpressionParameterAssociation> SetupActiveProperties(List<MshParameter> rawMshParameterList,
                                                   PSObject target, MshExpressionFactory expressionFactory)
        {
            // check if we received properties from the command line
            if (rawMshParameterList != null && rawMshParameterList.Count > 0)
            {
                return AssociationManager.ExpandParameters(rawMshParameterList, target);
            }

            // we did not get any properties:
            //try to get properties from the default property set of the object
            List<MshResolvedExpressionParameterAssociation> activeAssociationList = AssociationManager.ExpandDefaultPropertySet(target, expressionFactory);

            if (activeAssociationList.Count > 0)
            {
                // we got a valid set of properties from the default property set..add computername for
                // remoteobjects (if available)
                if (PSObjectHelper.ShouldShowComputerNameProperty(target))
                {
                    activeAssociationList.Add(new MshResolvedExpressionParameterAssociation(null,
                        new MshExpression(RemotingConstants.ComputerNameNoteProperty)));
                }

                return activeAssociationList;
            }

            // we failed to get anything from the default property set
            // just get all the properties
            activeAssociationList = AssociationManager.ExpandAll(target);
            // Remove PSComputerName and PSShowComputerName from the display as needed.
            AssociationManager.HandleComputerNameProperties(target, activeAssociationList);

            return activeAssociationList;
        }

 internal static void ToPSObjectForRemoting(CommandInfo commandInfo, PSObject psObject)
 {
     RemotingEncoder.ValueGetterDelegate<CommandTypes> valueGetter = null;
     RemotingEncoder.ValueGetterDelegate<string> delegate3 = null;
     RemotingEncoder.ValueGetterDelegate<string> delegate4 = null;
     RemotingEncoder.ValueGetterDelegate<SessionStateEntryVisibility> delegate5 = null;
     if (commandInfo != null)
     {
         if (valueGetter == null)
         {
             valueGetter = () => commandInfo.CommandType;
         }
         RemotingEncoder.AddNoteProperty<CommandTypes>(psObject, "CommandInfo_CommandType", valueGetter);
         if (delegate3 == null)
         {
             delegate3 = () => commandInfo.Definition;
         }
         RemotingEncoder.AddNoteProperty<string>(psObject, "CommandInfo_Definition", delegate3);
         if (delegate4 == null)
         {
             delegate4 = () => commandInfo.Name;
         }
         RemotingEncoder.AddNoteProperty<string>(psObject, "CommandInfo_Name", delegate4);
         if (delegate5 == null)
         {
             delegate5 = () => commandInfo.Visibility;
         }
         RemotingEncoder.AddNoteProperty<SessionStateEntryVisibility>(psObject, "CommandInfo_Visibility", delegate5);
     }
 }

        /// <summary>
        /// Converts a <see cref="JObject"/> to a <see cref="PSObject"/>
        /// </summary>
        /// <param name="jtoken">The <see cref="JObject"/></param>
        /// <param name="objectType">The type of the object.</param>
        internal static PSObject ToPsObject(this JToken jtoken, string objectType = null)
        {
            if (jtoken == null)
            {
                return null;
            }

            if (jtoken.Type != JTokenType.Object)
            {
                return new PSObject(JTokenExtensions.ConvertPropertyValueForPsObject(propertyValue: jtoken));
            }

            var jobject = (JObject)jtoken;
            var psObject = new PSObject();

            if (!string.IsNullOrWhiteSpace(objectType))
            {
                psObject.TypeNames.Add(objectType);
            }

            foreach (var property in jobject.Properties())
            {
                psObject.Properties.Add(new PSNoteProperty(
                    name: property.Name,
                    value: JTokenExtensions.ConvertPropertyValueForPsObject(propertyValue: property.Value)));
            }

            return psObject;
        }

 internal PSEventArgs(string computerName, Guid runspaceId, int eventIdentifier, string sourceIdentifier, object sender, object[] originalArgs, PSObject additionalData)
 {
     if (originalArgs != null)
     {
         foreach (object obj2 in originalArgs)
         {
             EventArgs args = obj2 as EventArgs;
             if (args != null)
             {
                 this.sourceEventArgs = args;
                 break;
             }
             if (ForwardedEventArgs.IsRemoteSourceEventArgs(obj2))
             {
                 this.sourceEventArgs = new ForwardedEventArgs((PSObject) obj2);
                 break;
             }
         }
     }
     this.computerName = computerName;
     this.runspaceId = runspaceId;
     this.eventIdentifier = eventIdentifier;
     this.sender = sender;
     this.sourceArgs = originalArgs;
     this.sourceIdentifier = sourceIdentifier;
     this.timeGenerated = DateTime.Now;
     this.data = additionalData;
     this.forwardEvent = false;
 }

        public ExecutableNodeFactory(Executable executable,Executables collection)
        {
            _collection = collection;
            _executable = (DtsContainer)executable;
            _host = _executable as TaskHost;
            _seq = _executable as Sequence;
            _foreachloop = _executable as ForEachLoop;
            _forloop = _executable as ForLoop;
            _psExecutable = PSObject.AsPSObject(_executable);

            if (null != _host)
            {
                _psExecutable.Properties.Add( new PSNoteProperty( "IsTaskHost", true ));
                _mainPipe = _host.InnerObject as MainPipe;
            }
            if (null != _mainPipe)
            {
                _psExecutable.Properties.Add(new PSNoteProperty("IsDataFlow", true));
            }
            if (null != _seq)
            {
                _psExecutable.Properties.Add(new PSNoteProperty("IsSequence", true));
            }
            if (null != _foreachloop)
            {
                _psExecutable.Properties.Add(new PSNoteProperty("IsForEachLoop", true));
            }
            if (null != _forloop)
            {
                _psExecutable.Properties.Add(new PSNoteProperty("IsForLoop", true));
            }
        }

 internal static List<MshResolvedExpressionParameterAssociation> ExpandAll(PSObject target)
 {
     List<string> propertyNamesFromView = GetPropertyNamesFromView(target, PSMemberViewTypes.Adapted);
     List<string> list2 = GetPropertyNamesFromView(target, PSMemberViewTypes.Base);
     List<string> collection = GetPropertyNamesFromView(target, PSMemberViewTypes.Extended);
     List<string> list4 = new List<string>();
     if (propertyNamesFromView.Count != 0)
     {
         list4 = propertyNamesFromView;
     }
     else
     {
         list4 = list2;
     }
     list4.AddRange(collection);
     Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
     List<MshResolvedExpressionParameterAssociation> list5 = new List<MshResolvedExpressionParameterAssociation>();
     foreach (string str in list4)
     {
         if (!dictionary.ContainsKey(str))
         {
             dictionary.Add(str, null);
             MshExpression expression = new MshExpression(str, true);
             list5.Add(new MshResolvedExpressionParameterAssociation(null, expression));
         }
     }
     return list5;
 }

        protected override void ProcessRecord()
        {
            base.ProcessRecord();
            string Filter = "(&(objectCategory=group)(name=" + Name + "))";
            string Scope = "Subtree";
            string[] Properties = null;

            SearchResultCollection AdGroupObject = Utilities.Functions.QueryAD(Path, Filter, Scope, Properties);
            foreach (SearchResult Group in AdGroupObject)
            {
                foreach (string Member in Group.Properties["member"])
                {
                    foreach (SearchResult AdObject in (Utilities.Functions.QueryAD("LDAP://" + Member, "", "Base", null)))
                    {
                        WriteVerbose("Create PowerShell object to hold return values");
                        PSObject objReturn = new PSObject();
                        WriteVerbose("Add AdObject.Properties to PowerShell object");
                        foreach (string AdProperty in AdObject.Properties.PropertyNames)
                        {
                            WriteDebug("Add property : " + AdProperty);
                            objReturn.Properties.Add(new PSNoteProperty(AdProperty, (AdObject.Properties[AdProperty])[0]));
                        }
                        WriteObject(objReturn);
                    }
                }
            }
        }

 private void AddProperties(PSObject psobj)
 {
     foreach (var keyObj in Property.Keys)
     {
         var key = keyObj.ToString(); // should be a string anyway
         var member = psobj.Members[key];
         if (member == null)
         {
             if (psobj.BaseObject is PSCustomObject)
             {
                 var noteProperty = new PSNoteProperty(key, Property[key]);
                 AddMemberToCollection(psobj.Properties, noteProperty, false);
                 AddMemberToCollection(psobj.Members, noteProperty, false);
             }
             else
             {
                 var msg = String.Format("A member with the name {0} doesn't exist", key);
                 WriteError(new PSInvalidOperationException(msg).ErrorRecord);
             }
         }
         else if (member is PSMethodInfo)
         {
             var method = member as PSMethodInfo;
             method.Invoke(Property[key]);
         }
         else if (member is PSPropertyInfo)
         {
             var psproperty = member as PSPropertyInfo;
             psproperty.Value = Property[key];
         }
     }
 }

        public IEnumerable<String> ProcessRecord(PSObject record)
        {
            if (record == null)
            {
                yield break;
            }

            if (_raw)
            {
                yield return record.ToString();
            }
            else
            {
                if (_pipeline == null)
                {
                    _pipeline = CreatePipeline();
                    _pipeline.InvokeAsync();
                }

                _pipeline.Input.Write(record);

                foreach (PSObject result in _pipeline.Output.NonBlockingRead())
                {
                    yield return result.ToString();
                }
            }
        }