internal static MethodInfo FindBestMethod(DynamicMetaObject target, IEnumerable <DynamicMetaObject> args, string methodName, bool @static, PSMethodInvocationConstraints invocationConstraints)
{
bool flag = false;
MethodInfo methodInfo = null;
PSMethod dotNetMethod = PSObject.dotNetInstanceAdapter.GetDotNetMethod <PSMethod>(PSObject.Base(target.Value), methodName);
if (dotNetMethod != null)
{
DotNetAdapter.MethodCacheEntry methodCacheEntry = (DotNetAdapter.MethodCacheEntry)dotNetMethod.adapterData;
string str = null;
string str1 = null;
MethodInformation[] methodInformationArray = methodCacheEntry.methodInformationStructures;
PSMethodInvocationConstraints pSMethodInvocationConstraint = invocationConstraints;
IEnumerable <DynamicMetaObject> dynamicMetaObjects = args;
MethodInformation methodInformation = Adapter.FindBestMethod(methodInformationArray, pSMethodInvocationConstraint, dynamicMetaObjects.Select <DynamicMetaObject, object>((DynamicMetaObject arg) =>
{
if (arg.Value == AutomationNull.Value)
{
return(null);
}
else
{
return(arg.Value);
}
}
).ToArray <object>(), ref str, ref str1, out flag);
if (methodInformation != null)
{
methodInfo = (MethodInfo)methodInformation.method;
}
}
return(methodInfo);
}
public static PSMethod CreatePSMethod(string name, DotNetAdapter dotNetInstanceAdapter, object baseObject, MethodCacheEntry method, bool isSpecial, bool isHidden)
{
return(PSMethod.Create(
name,
dotNetInstanceAdapter,
baseObject,
method,
isSpecial,
isHidden));
}
/// <summary>
/// This method implements the ProcessRecord method for get-member command.
/// </summary>
protected override void ProcessRecord()
{
if (this.InputObject == null || this.InputObject == AutomationNull.Value)
{
return;
}
Type baseObjectAsType = null;
string typeName;
Adapter staticAdapter = null;
if (this.Static == true)
{
staticAdapter = PSObject.DotNetStaticAdapter;
object baseObject = this.InputObject.BaseObject;
baseObjectAsType = baseObject as System.Type ?? baseObject.GetType();
typeName = baseObjectAsType.FullName;
}
else
{
var typeNames = this.InputObject.InternalTypeNames;
if (typeNames.Count != 0)
{
typeName = typeNames[0];
}
else
{
// This is never used for display. It is used only as a key to typesAlreadyDisplayed
typeName = "<null>";
}
}
if (_typesAlreadyDisplayed.Contains(typeName))
{
return;
}
else
{
_typesAlreadyDisplayed.Add(typeName, string.Empty);
}
PSMemberTypes memberTypeToSearch = MemberType;
PSMemberViewTypes viewToSearch = View;
if (((View & PSMemberViewTypes.Extended) == 0) &&
(!typeof(PSMemberSet).ToString().Equals(typeName, StringComparison.OrdinalIgnoreCase)))
{
// PSMemberSet is an internal memberset and its properties/methods are populated differently.
// PSMemberSet instance is created to represent PSExtended, PSAdapted, PSBase, PSObject hidden
// properties. We should honor extended properties for such case.
// request is to search dotnet or adapted or both members.
// dotnet,adapted members cannot be Script*,Note*,Code*
memberTypeToSearch ^= (PSMemberTypes.AliasProperty | PSMemberTypes.CodeMethod | PSMemberTypes.CodeProperty
| PSMemberTypes.MemberSet | PSMemberTypes.NoteProperty | PSMemberTypes.PropertySet | PSMemberTypes.ScriptMethod
| PSMemberTypes.ScriptProperty);
}
if (((View & PSMemberViewTypes.Adapted) == 0) && (View & PSMemberViewTypes.Base) == 0)
{
// base and adapted are not mentioned in the view so ignore respective properties
memberTypeToSearch ^= (PSMemberTypes.Property | PSMemberTypes.ParameterizedProperty | PSMemberTypes.Method);
}
if (((View & PSMemberViewTypes.Base) == PSMemberViewTypes.Base) &&
(InputObject.InternalBaseDotNetAdapter == null))
{
// the input object don't have a custom adapter..
// for this case adapted view and base view are the same.
viewToSearch |= PSMemberViewTypes.Adapted;
}
PSMemberInfoCollection <PSMemberInfo> membersToSearch;
if (this.Static == true)
{
membersToSearch = staticAdapter.BaseGetMembers <PSMemberInfo>(baseObjectAsType);
}
else
{
Collection <CollectionEntry <PSMemberInfo> > memberCollection = PSObject.GetMemberCollection(viewToSearch);
membersToSearch = new PSMemberInfoIntegratingCollection <PSMemberInfo>(this.InputObject, memberCollection);
}
foreach (string nameElement in this.Name)
{
ReadOnlyPSMemberInfoCollection <PSMemberInfo> readOnlyMembers;
readOnlyMembers = membersToSearch.Match(nameElement, memberTypeToSearch, _matchOptions);
MemberDefinition[] members = new MemberDefinition[readOnlyMembers.Count];
int resultCount = 0;
foreach (PSMemberInfo member in readOnlyMembers)
{
if (!Force)
{
PSMethod memberAsPSMethod = member as PSMethod;
if ((memberAsPSMethod != null) && (memberAsPSMethod.IsSpecial))
{
continue;
}
}
members[resultCount] = new MemberDefinition(typeName, member.Name, member.MemberType, member.ToString());
resultCount++;
}
Array.Sort <MemberDefinition>(members, 0, resultCount, new MemberComparer());
for (int index = 0; index < resultCount; index++)
{
this.WriteObject(members[index]);
}
}
}
public override DynamicMetaObject FallbackInvokeMember(DynamicMetaObject target, DynamicMetaObject[] args, DynamicMetaObject errorSuggestion)
{
PSMemberInfo pSMemberInfo = null;
BindingRestrictions bindingRestriction = null;
bool flag = false;
Type type = null;
Expression expression;
Type value;
MethodInformation[] methodInformationArray;
Type type1;
if (target.HasValue)
{
DynamicMetaObject[] dynamicMetaObjectArray = args;
if (!dynamicMetaObjectArray.Where <DynamicMetaObject>((DynamicMetaObject arg) => !arg.HasValue).Any <DynamicMetaObject>())
{
object obj = PSObject.Base(target.Value);
if (obj != null)
{
if (!this._getMemberBinder.HasInstanceMember || !PSGetMemberBinder.TryGetInstanceMember(target.Value, base.Name, out pSMemberInfo))
{
PSMethodInfo pSMethodInfo = this._getMemberBinder.GetPSMemberInfo(target, out bindingRestriction, out flag, out type, null, null) as PSMethodInfo;
DynamicMetaObject[] dynamicMetaObjectArray1 = args;
BindingRestrictions bindingRestriction1 = bindingRestriction;
bindingRestriction = dynamicMetaObjectArray1.Aggregate <DynamicMetaObject, BindingRestrictions>(bindingRestriction1, (BindingRestrictions current, DynamicMetaObject arg) => current.Merge(arg.PSGetMethodArgumentRestriction()));
if (ExecutionContext.HasEverUsedConstrainedLanguage)
{
bindingRestriction = bindingRestriction.Merge(BinderUtils.GetLanguageModeCheckIfHasEverUsedConstrainedLanguage());
ExecutionContext executionContextFromTLS = LocalPipeline.GetExecutionContextFromTLS();
DynamicMetaObject dynamicMetaObject = PSGetMemberBinder.EnsureAllowedInLanguageMode(executionContextFromTLS.LanguageMode, target, obj, base.Name, this._static, args, bindingRestriction, "MethodInvocationNotSupportedInConstrainedLanguage", ParserStrings.InvokeMethodConstrainedLanguage);
if (dynamicMetaObject != null)
{
return(dynamicMetaObject.WriteToDebugLog(this));
}
}
if (flag)
{
PSObject pSObject = target.Value as PSObject;
if (pSObject != null && (obj.GetType().Equals(typeof(Hashtable)) || obj.GetType().Equals(typeof(ArrayList))))
{
if (!pSObject.isDeserialized)
{
bindingRestriction = bindingRestriction.Merge(BindingRestrictions.GetExpressionRestriction(Expression.Not(Expression.Field(target.Expression.Cast(typeof(PSObject)), CachedReflectionInfo.PSObject_isDeserialized))));
}
else
{
pSMethodInfo = null;
bindingRestriction = bindingRestriction.Merge(BindingRestrictions.GetExpressionRestriction(Expression.Field(target.Expression.Cast(typeof(PSObject)), CachedReflectionInfo.PSObject_isDeserialized)));
}
}
PSMethod pSMethod = pSMethodInfo as PSMethod;
if (pSMethod == null)
{
PSScriptMethod pSScriptMethod = pSMethodInfo as PSScriptMethod;
if (pSScriptMethod == null)
{
PSCodeMethod pSCodeMethod = pSMethodInfo as PSCodeMethod;
if (pSCodeMethod == null)
{
PSParameterizedProperty pSParameterizedProperty = pSMethodInfo as PSParameterizedProperty;
if (pSParameterizedProperty == null)
{
if (errorSuggestion == null)
{
if (this._static)
{
value = (Type)target.Value;
}
else
{
value = PSObject.Base(target.Value).GetType();
}
Type type2 = value;
if (!this._static && !this._nonEnumerating && target.Value != AutomationNull.Value)
{
DynamicMetaObject dynamicMetaObject1 = PSEnumerableBinder.IsEnumerable(target);
if (dynamicMetaObject1 != null)
{
return(this.InvokeMemberOnCollection(dynamicMetaObject1, args, type2, bindingRestriction));
}
}
Expression[] expressionArray = new Expression[2];
expressionArray[0] = Expression.Constant(type2.FullName);
expressionArray[1] = Expression.Constant(base.Name);
return(new DynamicMetaObject(Compiler.ThrowRuntimeError("MethodNotFound", ParserStrings.MethodNotFound, expressionArray), bindingRestriction).WriteToDebugLog(this));
}
else
{
return(errorSuggestion.WriteToDebugLog(this));
}
}
else
{
DotNetAdapter.ParameterizedPropertyCacheEntry parameterizedPropertyCacheEntry = (DotNetAdapter.ParameterizedPropertyCacheEntry)pSParameterizedProperty.adapterData;
PSInvokeMemberBinder pSInvokeMemberBinder = this;
DynamicMetaObject dynamicMetaObject2 = target;
DynamicMetaObject[] dynamicMetaObjectArray2 = args;
BindingRestrictions bindingRestriction2 = bindingRestriction;
if (this._propertySetter)
{
methodInformationArray = parameterizedPropertyCacheEntry.setterInformation;
}
else
{
methodInformationArray = parameterizedPropertyCacheEntry.getterInformation;
}
if (this._propertySetter)
{
type1 = typeof(SetValueInvocationException);
}
else
{
type1 = typeof(GetValueInvocationException);
}
return(pSInvokeMemberBinder.InvokeDotNetMethod(dynamicMetaObject2, dynamicMetaObjectArray2, bindingRestriction2, methodInformationArray, type1).WriteToDebugLog(this));
}
}
else
{
return(new DynamicMetaObject(PSInvokeMemberBinder.InvokeMethod(pSCodeMethod.CodeReference, null, args.Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>(), false).Cast(typeof(object)), bindingRestriction).WriteToDebugLog(this));
}
}
else
{
MethodInfo pSScriptMethodInvokeScript = CachedReflectionInfo.PSScriptMethod_InvokeScript;
ConstantExpression constantExpression = Expression.Constant(base.Name);
ConstantExpression constantExpression1 = Expression.Constant(pSScriptMethod.Script);
Expression expression1 = target.Expression.Cast(typeof(object));
Type type3 = typeof(object);
DynamicMetaObject[] dynamicMetaObjectArray3 = args;
return(new DynamicMetaObject(Expression.Call(pSScriptMethodInvokeScript, constantExpression, constantExpression1, expression1, Expression.NewArrayInit(type3, dynamicMetaObjectArray3.Select <DynamicMetaObject, Expression>((DynamicMetaObject e) => e.Expression.Cast(typeof(object))))), bindingRestriction).WriteToDebugLog(this));
}
}
else
{
DotNetAdapter.MethodCacheEntry methodCacheEntry = (DotNetAdapter.MethodCacheEntry)pSMethod.adapterData;
return(this.InvokeDotNetMethod(target, args, bindingRestriction, methodCacheEntry.methodInformationStructures, typeof(MethodException)).WriteToDebugLog(this));
}
}
else
{
if (!this._propertySetter)
{
MethodInfo pSInvokeMemberBinderInvokeAdaptedMember = CachedReflectionInfo.PSInvokeMemberBinder_InvokeAdaptedMember;
Expression expression2 = PSGetMemberBinder.GetTargetExpr(target).Cast(typeof(object));
ConstantExpression constantExpression2 = Expression.Constant(base.Name);
Type type4 = typeof(object);
DynamicMetaObject[] dynamicMetaObjectArray4 = args;
expression = Expression.Call(pSInvokeMemberBinderInvokeAdaptedMember, expression2, constantExpression2, Expression.NewArrayInit(type4, dynamicMetaObjectArray4.Select <DynamicMetaObject, Expression>((DynamicMetaObject arg) => arg.Expression.Cast(typeof(object)))));
}
else
{
MethodInfo pSInvokeMemberBinderInvokeAdaptedSetMember = CachedReflectionInfo.PSInvokeMemberBinder_InvokeAdaptedSetMember;
Expression expression3 = PSGetMemberBinder.GetTargetExpr(target).Cast(typeof(object));
ConstantExpression constantExpression3 = Expression.Constant(base.Name);
Type type5 = typeof(object);
IEnumerable <DynamicMetaObject> dynamicMetaObjects = args.Take <DynamicMetaObject>((int)args.Length - 1);
expression = Expression.Call(pSInvokeMemberBinderInvokeAdaptedSetMember, expression3, constantExpression3, Expression.NewArrayInit(type5, dynamicMetaObjects.Select <DynamicMetaObject, Expression>((DynamicMetaObject arg) => arg.Expression.Cast(typeof(object)))), args.Last <DynamicMetaObject>().Expression.Cast(typeof(object)));
}
return(new DynamicMetaObject(expression, bindingRestriction).WriteToDebugLog(this));
}
}
else
{
ParameterExpression parameterExpression = Expression.Variable(typeof(PSMethodInfo));
MethodCallExpression methodCallExpression = Expression.Call(CachedReflectionInfo.PSInvokeMemberBinder_TryGetInstanceMethod, target.Expression.Cast(typeof(object)), Expression.Constant(base.Name), parameterExpression);
ParameterExpression parameterExpression1 = parameterExpression;
MethodInfo pSMethodInfoInvoke = CachedReflectionInfo.PSMethodInfo_Invoke;
Expression[] expressionArray1 = new Expression[1];
Expression[] expressionArray2 = expressionArray1;
int num = 0;
Type type6 = typeof(object);
DynamicMetaObject[] dynamicMetaObjectArray5 = args;
expressionArray2[num] = Expression.NewArrayInit(type6, dynamicMetaObjectArray5.Select <DynamicMetaObject, Expression>((DynamicMetaObject dmo) => dmo.Expression.Cast(typeof(object))));
ConditionalExpression conditionalExpression = Expression.Condition(methodCallExpression, Expression.Call(parameterExpression1, pSMethodInfoInvoke, expressionArray1), base.GetUpdateExpression(typeof(object)));
ParameterExpression[] parameterExpressionArray = new ParameterExpression[1];
parameterExpressionArray[0] = parameterExpression;
Expression[] expressionArray3 = new Expression[1];
expressionArray3[0] = conditionalExpression;
return(new DynamicMetaObject(Expression.Block(parameterExpressionArray, expressionArray3), BinderUtils.GetVersionCheck(this._getMemberBinder, this._getMemberBinder._version)).WriteToDebugLog(this));
}
}
else
{
return(target.ThrowRuntimeError(args, BindingRestrictions.Empty, "InvokeMethodOnNull", ParserStrings.InvokeMethodOnNull, new Expression[0]).WriteToDebugLog(this));
}
}
}
return(base.Defer(args.Prepend <DynamicMetaObject>(target).ToArray <DynamicMetaObject>()));
}
protected override void ProcessRecord()
{
if ((this.InputObject != null) && (this.InputObject != AutomationNull.Value))
{
string fullName;
Type type = null;
Adapter dotNetStaticAdapter = null;
if (this.Static == 1)
{
dotNetStaticAdapter = PSObject.dotNetStaticAdapter;
object baseObject = this.InputObject.BaseObject;
type = baseObject as Type;
if (type == null)
{
type = baseObject.GetType();
}
fullName = type.FullName;
}
else
{
ConsolidatedString internalTypeNames = this.InputObject.InternalTypeNames;
if (internalTypeNames.Count != 0)
{
fullName = internalTypeNames[0];
}
else
{
fullName = "<null>";
}
}
if (!this.typesAlreadyDisplayed.Contains(fullName))
{
PSMemberInfoCollection <PSMemberInfo> infos;
this.typesAlreadyDisplayed.Add(fullName, "");
PSMemberTypes memberType = this.memberType;
PSMemberViewTypes view = this.view;
if (((this.view & PSMemberViewTypes.Extended) == 0) && !typeof(PSMemberSet).ToString().Equals(fullName, StringComparison.OrdinalIgnoreCase))
{
memberType ^= PSMemberTypes.MemberSet | PSMemberTypes.ScriptMethod | PSMemberTypes.CodeMethod | PSMemberTypes.PropertySet | PSMemberTypes.ScriptProperty | PSMemberTypes.NoteProperty | PSMemberTypes.CodeProperty | PSMemberTypes.AliasProperty;
}
if (((this.view & PSMemberViewTypes.Adapted) == 0) && ((this.view & PSMemberViewTypes.Base) == 0))
{
memberType ^= PSMemberTypes.ParameterizedProperty | PSMemberTypes.Method | PSMemberTypes.Property;
}
if (((this.view & PSMemberViewTypes.Base) == PSMemberViewTypes.Base) && (this.InputObject.InternalBaseDotNetAdapter == null))
{
view |= PSMemberViewTypes.Adapted;
}
if (this.Static == 1)
{
infos = dotNetStaticAdapter.BaseGetMembers <PSMemberInfo>(type);
}
else
{
Collection <CollectionEntry <PSMemberInfo> > memberCollection = PSObject.GetMemberCollection(view);
infos = new PSMemberInfoIntegratingCollection <PSMemberInfo>(this.InputObject, memberCollection);
}
foreach (string str3 in this.Name)
{
ReadOnlyPSMemberInfoCollection <PSMemberInfo> infos2 = infos.Match(str3, memberType, this.matchOptions);
MemberDefinition[] array = new MemberDefinition[infos2.Count];
int index = 0;
foreach (PSMemberInfo info in infos2)
{
if (this.Force == 0)
{
PSMethod method = info as PSMethod;
if ((method != null) && method.IsSpecial)
{
continue;
}
}
array[index] = new MemberDefinition(fullName, info.Name, info.MemberType, info.ToString());
index++;
}
Array.Sort <MemberDefinition>(array, 0, index, new MemberComparer());
for (int i = 0; i < index; i++)
{
base.WriteObject(array[i]);
}
}
}
}
}
