private Attribute GetCustomAttribute() { Attribute customAttributeObject = this.GetCustomAttributeObject(); if (customAttributeObject != null && this._namedArguments != null) { Hashtable constValue = (Hashtable)this._namedArguments.GetConstValue(); PSObject psObject = LanguagePrimitives.AsPSObjectOrNull((object)customAttributeObject); foreach (object key in (IEnumerable)constValue.Keys) { object obj = constValue[key]; try { PSMemberInfo member = psObject.Members[key.ToString()]; if (member != null) { member.Value = obj; } else { throw InterpreterError.NewInterpreterException((object)this.NodeToken, typeof(RuntimeException), this.NodeToken, "PropertyNotFoundForType", (object)key.ToString(), (object)customAttributeObject.GetType().ToString()); } } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); throw InterpreterError.NewInterpreterExceptionByMessage(typeof(RuntimeException), this.NodeToken, ex.Message, "PropertyAssignmentException", ex); } } } return(customAttributeObject); }
private void LookupMember(string name, HybridDictionary visitedAliases, out PSMemberInfo returnedMember, out bool hasCycle) { returnedMember = null; if (base.instance == null) { throw new ExtendedTypeSystemException("AliasLookupMemberOutsidePSObject", null, ExtendedTypeSystem.AccessMemberOutsidePSObject, new object[] { name }); } PSMemberInfo info = PSObject.AsPSObject(base.instance).Properties[name]; if (info == null) { throw new ExtendedTypeSystemException("AliasLookupMemberNotPresent", null, ExtendedTypeSystem.MemberNotPresent, new object[] { name }); } PSAliasProperty property = info as PSAliasProperty; if (property == null) { hasCycle = false; returnedMember = info; } else if (visitedAliases.Contains(name)) { hasCycle = true; } else { visitedAliases.Add(name, name); this.LookupMember(property.ReferencedMemberName, visitedAliases, out returnedMember, out hasCycle); } }
private PSMemberInfoInternalCollection <T> GetIntegratedMembers( MshMemberMatchOptions matchOptions) { using (PSObject.memberResolution.TraceScope("Generating the total list of members")) { PSMemberInfoInternalCollection <T> internalCollection = new PSMemberInfoInternalCollection <T>(); PSObject particularInstance; if (this.mshOwner != null) { particularInstance = this.mshOwner; foreach (PSMemberInfo instanceMember in (PSMemberInfoCollection <PSMemberInfo>) this.mshOwner.InstanceMembers) { if (instanceMember.MatchesOptions(matchOptions) && instanceMember is T member) { internalCollection.Add(member); } } } else { particularInstance = this.memberSetOwner.instance; foreach (PSMemberInfo internalMember in (PSMemberInfoCollection <PSMemberInfo>) this.memberSetOwner.InternalMembers) { if (internalMember.MatchesOptions(matchOptions) && internalMember is T member) { internalMember.ReplicateInstance(particularInstance); internalCollection.Add(member); } } } foreach (CollectionEntry <T> collection in this.collections) { foreach (T obj in (PSMemberInfoCollection <T>)collection.GetMembers(particularInstance)) { PSMemberInfo psMemberInfo = (PSMemberInfo)internalCollection[obj.Name]; if (psMemberInfo != 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.", (object)obj.Name, (object)obj.MemberType, (object)psMemberInfo.MemberType); } else if (!obj.MatchesOptions(matchOptions)) { PSObject.memberResolution.WriteLine("Skipping hidden member \"{0}\".", (object)obj.Name); } else { T member = !collection.ShouldCloneWhenReturning ? obj : (T)obj.Copy(); if (collection.ShouldReplicateWhenReturning) { member.ReplicateInstance(particularInstance); } internalCollection.Add(member); } } } return(internalCollection); } }
internal void CloneBaseProperties(PSMemberInfo destiny) { destiny.name = this.name; destiny.isHidden = this.isHidden; destiny.isReservedMember = this.isReservedMember; destiny.isInstance = this.isInstance; destiny.instance = this.instance; destiny.shouldSerialize = this.shouldSerialize; }
internal void CloneBaseProperties(PSMemberInfo destiny) { destiny.name = this.name; destiny.isHidden = this.isHidden; destiny.isReservedMember = this.isReservedMember; destiny.isInstance = this.isInstance; destiny.instance = this.instance; destiny.shouldSerialize = this.shouldSerialize; }
private void ProcessOutputHelper() { for (object obj = this.outputReader.Read(); obj != AutomationNull.Value; obj = this.outputReader.Read()) { ProcessOutputObject processOutputObject = obj as ProcessOutputObject; if (processOutputObject.Stream == MinishellStream.Error) { ErrorRecord data = processOutputObject.Data as ErrorRecord; data.SetInvocationInfo(this.Command.MyInvocation); this.commandRuntime._WriteErrorSkipAllowCheck(data); } else if (processOutputObject.Stream == MinishellStream.Output) { this.commandRuntime._WriteObjectSkipAllowCheck(processOutputObject.Data); } else if (processOutputObject.Stream == MinishellStream.Debug) { this.Command.PSHostInternal.UI.WriteDebugLine(processOutputObject.Data as string); } else if (processOutputObject.Stream == MinishellStream.Verbose) { this.Command.PSHostInternal.UI.WriteVerboseLine(processOutputObject.Data as string); } else if (processOutputObject.Stream == MinishellStream.Warning) { this.Command.PSHostInternal.UI.WriteWarningLine(processOutputObject.Data as string); } else if (processOutputObject.Stream == MinishellStream.Progress && processOutputObject.Data is PSObject data) { long sourceId = 0; PSMemberInfo property1 = (PSMemberInfo)data.Properties["SourceId"]; if (property1 != null) { sourceId = (long)property1.Value; } PSMemberInfo property2 = (PSMemberInfo)data.Properties["Record"]; ProgressRecord record = (ProgressRecord)null; if (property2 != null) { record = property2.Value as ProgressRecord; } if (record != null) { this.Command.PSHostInternal.UI.WriteProgress(sourceId, record); } } if (this.Command.Context.CurrentPipelineStopping) { this.StopProcessing(); break; } } }
public override T this[string name] { get { using (PSObject.memberResolution.TraceScope("Lookup")) { if (string.IsNullOrEmpty(name)) { throw PSMemberInfoIntegratingCollection <T> .tracer.NewArgumentException(nameof (name)); } PSObject particularInstance; if (this.mshOwner != null) { this.EnsureReservedMemberIsLoaded(name); PSMemberInfo instanceMember = this.mshOwner.InstanceMembers[name]; particularInstance = this.mshOwner; if (instanceMember is T obj) { PSObject.memberResolution.WriteLine("Found PSObject instance member: {0}.", (object)name); return(obj); } } else { PSMemberInfo internalMember = this.memberSetOwner.InternalMembers[name]; particularInstance = this.memberSetOwner.instance; if (internalMember is T obj) { PSObject.memberResolution.WriteLine("Found PSMemberSet member: {0}.", (object)name); internalMember.ReplicateInstance(particularInstance); return(obj); } } foreach (CollectionEntry <T> collection in this.collections) { T obj = collection.GetMember(particularInstance, name); if ((object)obj != null) { if (collection.ShouldCloneWhenReturning) { obj = (T)obj.Copy(); } if (collection.ShouldReplicateWhenReturning) { obj.ReplicateInstance(particularInstance); } return(obj); } } return(default(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); }
internal object GetValue(PSObject obj, object property, ExecutionContext context) { if (!LanguagePrimitives.IsNull((object)obj)) { if (!LanguagePrimitives.IsNull(property)) { try { IDictionary dictionary = PSObject.Base((object)obj) as IDictionary; try { if (dictionary != null) { if (dictionary.Contains(property)) { return(dictionary[property]); } } } catch (InvalidOperationException ex) { } PSMemberInfo memberInfo = this.GetMemberInfo(obj, property, context); if (memberInfo != null) { return(memberInfo.Value); } } catch (TerminateException ex) { throw; } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); return((object)null); } } } if (context.IsStrictVersion(2)) { throw InterpreterError.NewInterpreterException((object)this.NodeToken, typeof(RuntimeException), this.NodeToken, "PropertyNotFoundStrict", property); } return((object)null); }
/// <summary> /// Ensures the 'UserName' and 'HandleCount' Properties exist the Process object. /// </summary> /// <param name="process"></param> /// <param name="includeUserName"></param> /// <returns></returns> internal static PSObject AddProcessProperties(bool includeUserName, Process process) { PSObject processAsPsobj = includeUserName ? AddUserNameToProcess(process) : PSObject.AsPSObject(process); #if CORECLR // In CoreCLR, the System.Diagnostics.Process.HandleCount property does not exist. // I am adding a note property HandleCount and temporarily setting it to zero. // This issue will be fix for RTM and it is tracked by 5024994: Get-process does not populate the Handles field. PSMemberInfo hasHandleCount = processAsPsobj.Properties["HandleCount"]; if (hasHandleCount == null) { PSNoteProperty noteProperty = new PSNoteProperty("HandleCount", 0); processAsPsobj.Properties.Add(noteProperty, true); processAsPsobj.TypeNames.Insert(0, "System.Diagnostics.Process#HandleCount"); } #endif return(processAsPsobj); }
private static object GenerateMemberSet(string name, object obj) { PSObject psObject = PSObject.AsPSObject(obj); PSMemberInfo member = psObject.InstanceMembers[name]; if (member == null) { PSInternalMemberSet set = new PSInternalMemberSet(name, psObject) { ShouldSerialize = false, isHidden = true, isReservedMember = true }; member = set; psObject.InstanceMembers.Add(member); member.instance = psObject; } return(member); }
private bool AddMemberToTarget(PSMemberInfo member) { PSMemberInfo info = this.inputObject.Members[member.Name]; if (info != null) { if (!this.force) { base.WriteError(this.NewError("MemberAlreadyExists", "MemberAlreadyExists", this.inputObject, new object[] { member.Name })); return false; } if (!info.IsInstance) { base.WriteError(this.NewError("CannotRemoveTypeDataMember", "CannotRemoveTypeDataMember", this.inputObject, new object[] { member.Name, info.MemberType })); return false; } this.inputObject.Members.Remove(member.Name); } this.inputObject.Members.Add(member); return true; }
internal static object GeneratePSExtendedMemberSet(object obj) { PSObject mshObject = PSObject.AsPSObject(obj); PSMemberInfo member = mshObject.InstanceMembers["psextended"]; if (member == null) { PSMemberSet set = new PSMemberSet("psextended", mshObject) { ShouldSerialize = false, isHidden = true, isReservedMember = true }; member = set; member.ReplicateInstance(mshObject); member.instance = mshObject; mshObject.InstanceMembers.Add(member); } return(member); }
public bool MoveNext() { ++this.currentIndex; PSMemberInfo psMemberInfo = (PSMemberInfo)null; for (; this.currentIndex < this.allMembers.Count; ++this.currentIndex) { psMemberInfo = (PSMemberInfo)this.allMembers.members[this.currentIndex]; if (!psMemberInfo.IsHidden) { break; } } if (this.currentIndex < this.allMembers.Count) { this.current = psMemberInfo as S; return(true); } this.current = default(S); return(false); }
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); } } }
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); } }
private void AddDynamicMemberAndScale(PSMemberInfo plotMember) { if (null == plotMember) { return; } SafeAddDynamicMember(plotMember); var name = plotMember.Name; AddDynamicScaleForProperty(name); }
public void AddDynamicMember(PSMemberInfo plotMember) { AddDynamicMemberAndScale(plotMember); }
private void ProcessOutputHelper() { for (object obj2 = this.outputReader.Read(); obj2 != AutomationNull.Value; obj2 = this.outputReader.Read()) { ProcessOutputObject obj3 = obj2 as ProcessOutputObject; if (obj3.Stream == MinishellStream.Error) { ErrorRecord data = obj3.Data as ErrorRecord; data.SetInvocationInfo(base.Command.MyInvocation); ActionPreference?actionPreference = null; base.commandRuntime._WriteErrorSkipAllowCheck(data, actionPreference); } else if (obj3.Stream == MinishellStream.Output) { base.commandRuntime._WriteObjectSkipAllowCheck(obj3.Data); } else if (obj3.Stream == MinishellStream.Debug) { string message = obj3.Data as string; base.Command.PSHostInternal.UI.WriteDebugLine(message); } else if (obj3.Stream == MinishellStream.Verbose) { string str2 = obj3.Data as string; base.Command.PSHostInternal.UI.WriteVerboseLine(str2); } else if (obj3.Stream == MinishellStream.Warning) { string str3 = obj3.Data as string; base.Command.PSHostInternal.UI.WriteWarningLine(str3); } else if (obj3.Stream == MinishellStream.Progress) { PSObject obj4 = obj3.Data as PSObject; if (obj4 != null) { long sourceId = 0L; PSMemberInfo info = obj4.Properties["SourceId"]; if (info != null) { sourceId = (long)info.Value; } info = obj4.Properties["Record"]; ProgressRecord record = null; if (info != null) { record = info.Value as ProgressRecord; } if (record != null) { base.Command.PSHostInternal.UI.WriteProgress(sourceId, record); } } } if (base.Command.Context.CurrentPipelineStopping) { this.StopProcessing(); return; } } }
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); } }
/// <summary> /// Add the member to the target object /// </summary> /// <param name="member"></param> /// <returns></returns> private bool AddMemberToTarget(PSMemberInfo member) { PSMemberInfo previousMember = _inputObject.Members[member.Name]; if (previousMember != null) { if (!_force) { WriteError(NewError("MemberAlreadyExists", "MemberAlreadyExists", _inputObject, member.Name)); return false; } else { if (previousMember.IsInstance) { _inputObject.Members.Remove(member.Name); } else { WriteError(NewError("CannotRemoveTypeDataMember", "CannotRemoveTypeDataMember", _inputObject, member.Name, previousMember.MemberType)); return false; } } } _inputObject.Members.Add(member); return true; }
public override void Add(T member) { PSMemberInfo mbrInfo = member.Copy(); _collection.Add(mbrInfo); }
private void SafeAddDynamicMember(PSMemberInfo plotMember) { using (_log.PushContext("SafeAddDynamicMember")) { if (null == plotMember) { _log.Debug("no plot member specified"); return; } if (!(from dm in _dynamicMembers where Name == plotMember.Name select dm).Any()) { _log.DebugFormat( "adding dynamic member [{0}]", plotMember.Name ); _dynamicMembers.Add(plotMember); } } }
public void AddDynamicMember(PSMemberInfo m) { }
/// <summary> /// This method tries to get name and value from <see cref="PSMemberInfo"/> and /// creates <see cref="ConnectorAttribute"/> out of it /// </summary> /// <param name="info">PSMemberInfo to get the data from</param> /// <returns>Created ConnectorAttribute or null if not possible to create it</returns> internal static ConnectorAttribute GetAsAttribute(PSMemberInfo info) { Assertions.NullCheck(info, "param"); if (info.Value != null) { string value = info.Value.ToString(); // TODO: add type recognition, currently only string is supported if (value != info.Value.GetType().ToString() && !string.IsNullOrEmpty(value)) { return ConnectorAttributeBuilder.Build(info.Name, value); } } return null; }