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