/// <summary>
/// Returns null if memberName is not a member in the adapter or
/// the corresponding PSMemberInfo
/// </summary>
/// <param name="obj">object to retrieve the PSMemberInfo from</param>
/// <param name="memberName">name of the member to be retrieved</param>
/// <returns>The PSMemberInfo corresponding to memberName from obj</returns>
protected override T GetMember <T>(object obj, string memberName)
{
ComProperty prop;
if (_comTypeInfo.Properties.TryGetValue(memberName, out prop))
{
if (prop.IsParameterized)
{
if (typeof(T).IsAssignableFrom(typeof(PSParameterizedProperty)))
{
return(new PSParameterizedProperty(prop.Name, this, obj, prop) as T);
}
}
else if (typeof(T).IsAssignableFrom(typeof(PSProperty)))
{
return(new PSProperty(prop.Name, this, obj, prop) as T);
}
}
ComMethod method;
if (typeof(T).IsAssignableFrom(typeof(PSMethod)) &&
(_comTypeInfo != null) && (_comTypeInfo.Methods.TryGetValue(memberName, out method)))
{
PSMethod mshMethod = new PSMethod(method.Name, this, obj, method);
return(mshMethod as T);
}
return(null);
}
public override PSMemberInfo Copy()
{
PSMethod destiny = new PSMethod(base.name, this.adapter, this.baseObject, this.adapterData, this.isSpecial);
base.CloneBaseProperties(destiny);
return(destiny);
}
protected override object MethodInvoke(PSMethod method, object[] arguments)
{
ManagementObject baseObject = method.baseObject as ManagementObject;
WMIMethodCacheEntry adapterData = (WMIMethodCacheEntry)method.adapterData;
return(this.AuxillaryInvokeMethod(baseObject, adapterData, arguments));
}
public override PSMemberInfo Copy()
{
PSMethod psMethod = new PSMethod(this.name, this.adapter, this.baseObject, this.adapterData, this.isSpecial);
this.CloneBaseProperties((PSMemberInfo)psMethod);
return((PSMemberInfo)psMethod);
}
protected override object MethodInvoke(PSMethod method, object[] arguments)
{
ParameterInformation[] arguments1 = new ParameterInformation[arguments.Length];
for (int index = 0; index < arguments.Length; ++index)
{
arguments1[index] = new ParameterInformation(typeof(object), false, (object)null, false);
}
MethodInformation[] methods = new MethodInformation[1]
{
new MethodInformation(false, false, arguments1)
};
object[] newArguments;
Adapter.GetBestMethodAndArguments(method.Name, methods, arguments, out newArguments);
DirectoryEntry baseObject = (DirectoryEntry)method.baseObject;
Exception exception;
try
{
return(baseObject.Invoke(method.Name, newArguments));
}
catch (DirectoryServicesCOMException ex)
{
exception = (Exception)ex;
}
catch (TargetInvocationException ex)
{
exception = (Exception)ex;
}
catch (COMException ex)
{
exception = (Exception)ex;
}
return((DirectoryEntryAdapter.dotNetAdapter.GetDotNetMethod <PSMethod>(method.baseObject, method.name) ?? throw exception).Invoke(arguments));
}
protected override T GetMember <T>(object obj, string memberName)
{
if (this._comTypeInfo.Properties.ContainsKey(memberName))
{
ComProperty adapterData = this._comTypeInfo.Properties[memberName];
if (adapterData.IsParameterized)
{
if (typeof(T).IsAssignableFrom(typeof(PSParameterizedProperty)))
{
return(new PSParameterizedProperty(adapterData.Name, this, obj, adapterData) as T);
}
}
else if (typeof(T).IsAssignableFrom(typeof(PSProperty)))
{
return(new PSProperty(adapterData.Name, this, obj, adapterData) as T);
}
}
if ((typeof(T).IsAssignableFrom(typeof(PSMethod)) && (this._comTypeInfo != null)) && this._comTypeInfo.Methods.ContainsKey(memberName))
{
ComMethod method = this._comTypeInfo.Methods[memberName];
PSMethod method2 = new PSMethod(method.Name, this, obj, method);
return(method2 as T);
}
return(default(T));
}
protected override Collection <string> MethodDefinitions(PSMethod method)
{
WMIMethodCacheEntry adapterData = (WMIMethodCacheEntry)method.adapterData;
return(new Collection <string> {
adapterData.MethodDefinition
});
}
/// <summary>
/// Called after a non null return from GetMember to return the overloads
/// </summary>
/// <param name="method">the return of GetMember</param>
/// <returns></returns>
protected override Collection <String> MethodDefinitions(PSMethod method)
{
WMIMethodCacheEntry methodEntry = (WMIMethodCacheEntry)method.adapterData;
Collection <string> returnValue = new Collection <string>();
returnValue.Add(methodEntry.MethodDefinition);
return(returnValue);
}
/// <summary>
/// Called after a non null return from GetMember to try to call
/// the method with the arguments
/// </summary>
/// <param name="method">the non empty return from GetMethods</param>
/// <param name="arguments">the arguments to use</param>
/// <returns>the return value for the method</returns>
protected override object MethodInvoke(PSMethod method, object[] arguments)
{
ParameterInformation[] parameters = new ParameterInformation[arguments.Length];
for (int i = 0; i < arguments.Length; i++)
{
parameters[i] = new ParameterInformation(typeof(System.Object), false, null, false);
}
MethodInformation[] methodInformation = new MethodInformation[1];
methodInformation[0] = new MethodInformation(false, false, parameters);
object[] newArguments;
GetBestMethodAndArguments(method.Name, methodInformation, arguments, out newArguments);
DirectoryEntry entry = (DirectoryEntry)method.baseObject;
// First try to invoke method on the native adsi object. If the method
// call fails, try to invoke dotnet method with same name, if one available.
// This will ensure dotnet methods are exposed for DE objects.
// The problem is in GetMember<T>(), DE adapter cannot check if a requested
// method is available as it doesn't have access to native adsi object's
// method metadata. So GetMember<T> returns PSMethod assuming a method
// is available. This behavior will never give a chance to dotnet adapter
// to resolve method call. So the DE adapter owns calling dotnet method
// if one available.
Exception exception;
try
{
return(entry.Invoke(method.Name, newArguments));
}
catch (DirectoryServicesCOMException dse)
{
exception = dse;
}
catch (TargetInvocationException tie)
{
exception = tie;
}
catch (COMException ce)
{
exception = ce;
}
// this code is reached only on exception
// check if there is a dotnet method, invoke the dotnet method if available
PSMethod dotNetmethod = s_dotNetAdapter.GetDotNetMethod <PSMethod>(method.baseObject, method.name);
if (null != dotNetmethod)
{
return(dotNetmethod.Invoke(arguments));
}
// else
throw exception;
}
/// <summary>
/// Called after a non null return from GetMember to try to call
/// the method with the arguments
/// </summary>
/// <param name="method">the non empty return from GetMethods</param>
/// <param name="arguments">the arguments to use</param>
/// <returns>the return value for the method</returns>
protected override object MethodInvoke(PSMethod method, object[] arguments)
{
ManagementObject mgmtObject = method.baseObject as ManagementObject;
Diagnostics.Assert(mgmtObject != null,
"Object is not of ManagementObject type");
WMIMethodCacheEntry methodEntry = (WMIMethodCacheEntry)method.adapterData;
return(AuxillaryInvokeMethod(mgmtObject, methodEntry, arguments));
}
protected virtual string MethodToString(PSMethod method)
{
StringBuilder stringBuilder = new StringBuilder();
foreach (string methodDefinition in this.MethodDefinitions(method))
{
stringBuilder.Append(methodDefinition);
stringBuilder.Append(", ");
}
stringBuilder.Remove(stringBuilder.Length - 2, 2);
return(stringBuilder.ToString());
}
internal object BaseMethodInvoke(PSMethod method, params object[] arguments)
{
try
{
return(this.MethodInvoke(method, arguments));
}
catch (TargetInvocationException ex)
{
Exception innerException = ex.InnerException == null ? (Exception)ex : ex.InnerException;
throw new MethodInvocationException("CatchFromBaseAdapterMethodInvokeTI", innerException, "ExtendedTypeSystem", "MethodInvocationException", new object[3]
{
(object)method.Name,
(object)arguments.Length,
(object)innerException.Message
});
}
catch (FlowControlException ex)
{
throw;
}
catch (ScriptCallDepthException ex)
{
throw;
}
catch (PipelineStoppedException ex)
{
throw;
}
catch (Exception ex)
{
if (ex is MethodException)
{
throw;
}
else
{
CommandProcessorBase.CheckForSevereException(ex);
if (method.baseObject is SteppablePipeline && (method.Name.Equals("Begin", StringComparison.OrdinalIgnoreCase) || method.Name.Equals("Process", StringComparison.OrdinalIgnoreCase) || method.Name.Equals("End", StringComparison.OrdinalIgnoreCase)))
{
throw;
}
else
{
throw new MethodInvocationException("CatchFromBaseAdapterMethodInvoke", ex, "ExtendedTypeSystem", "MethodInvocationException", new object[3]
{
(object)method.Name,
(object)arguments.Length,
(object)ex.Message
});
}
}
}
}
protected override string MethodToString(PSMethod method)
{
StringBuilder builder = new StringBuilder();
foreach (string str in this.MethodDefinitions(method))
{
builder.Append(str);
builder.Append(", ");
}
builder.Remove(builder.Length - 2, 2);
return(builder.ToString());
}
/// <summary>
/// Returns the string representation of the method in the object
/// </summary>
/// <returns>the string representation of the method in the object</returns>
protected override string MethodToString(PSMethod method)
{
StringBuilder returnValue = new StringBuilder();
foreach (string overload in MethodDefinitions(method))
{
returnValue.Append(overload);
returnValue.Append(", ");
}
returnValue.Remove(returnValue.Length - 2, 2);
return(returnValue.ToString());
}
/// <summary>
/// Invokes the method on object
/// </summary>
/// <param name="method">represents the instance of the method we want to invoke</param>
/// <param name="arguments">parameters to be passed to the method</param>
/// <returns>returns the value of method call</returns>
internal object InvokeMethod(PSMethod method, object[] arguments)
{
try
{
object[] newarguments;
var methods = ComUtil.GetMethodInformationArray(_typeInfo, _methods, false);
var bestMethod = (ComMethodInformation)Adapter.GetBestMethodAndArguments(Name, methods, arguments, out newarguments);
object returnValue = ComInvoker.Invoke(method.baseObject as IDispatch,
bestMethod.DispId, newarguments,
ComInvoker.GetByRefArray(bestMethod.parameters,
newarguments.Length,
isPropertySet: false),
COM.INVOKEKIND.INVOKE_FUNC);
Adapter.SetReferences(newarguments, bestMethod, arguments);
return(bestMethod.ReturnType != typeof(void) ? returnValue : AutomationNull.Value);
}
catch (TargetInvocationException te)
{
//First check if this is a severe exception.
CommandProcessorBase.CheckForSevereException(te.InnerException);
var innerCom = te.InnerException as COMException;
if (innerCom == null || innerCom.HResult != ComUtil.DISP_E_MEMBERNOTFOUND)
{
string message = te.InnerException == null ? te.Message : te.InnerException.Message;
throw new MethodInvocationException(
"ComMethodTargetInvocation",
te,
ExtendedTypeSystem.MethodInvocationException,
method.Name, arguments.Length, message);
}
}
catch (COMException ce)
{
if (ce.HResult != ComUtil.DISP_E_UNKNOWNNAME)
{
throw new MethodInvocationException(
"ComMethodCOMException",
ce,
ExtendedTypeSystem.MethodInvocationException,
method.Name, arguments.Length, ce.Message);
}
}
return(null);
}
internal object InvokeMethod(PSMethod method, object[] arguments)
{
Type type = method.baseObject.GetType();
BindingFlags invokeAttr = BindingFlags.IgnoreCase | BindingFlags.InvokeMethod;
try
{
object[] newArguments;
ComMethodInformation methodAndArguments = (ComMethodInformation)Adapter.GetBestMethodAndArguments(this.Name, (MethodInformation[])ComUtil.GetMethodInformationArray(this.typeInfo, this.methods, false), arguments, out newArguments);
object obj = type.InvokeMember(this.Name, invokeAttr, (Binder)null, method.baseObject, newArguments, ComUtil.GetModifiers(methodAndArguments.parameters), CultureInfo.CurrentCulture, (string[])null);
Adapter.SetReferences(newArguments, (MethodInformation)methodAndArguments, arguments);
return(methodAndArguments.ReturnType != typeof(void) ? obj : (object)AutomationNull.Value);
}
catch (TargetInvocationException ex)
{
CommandProcessorBase.CheckForSevereException(ex.InnerException);
if (ex.InnerException is COMException innerException)
{
if (innerException.ErrorCode == -2147352573)
{
goto label_9;
}
}
string str = ex.InnerException == null ? ex.Message : ex.InnerException.Message;
throw new MethodInvocationException("ComMethodTargetInvocation", (Exception)ex, "ExtendedTypeSystem", "MethodInvocationException", new object[3]
{
(object)method.Name,
(object)arguments.Length,
(object)str
});
}
catch (COMException ex)
{
if (ex.ErrorCode != -2147352570)
{
throw new MethodInvocationException("ComMethodCOMException", (Exception)ex, "ExtendedTypeSystem", "MethodInvocationException", new object[3]
{
(object)method.Name,
(object)arguments.Length,
(object)ex.Message
});
}
}
label_9:
return((object)null);
}
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);
}
}
internal string BaseMethodToString(PSMethod method)
{
try
{
return(this.MethodToString(method));
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
if (ex is ExtendedTypeSystemException)
{
throw;
}
else
{
throw this.NewException(ex, "CatchFromBaseMethodToString", "CatchFromBaseMethodToStringTI", "ExceptionRetrievingMethodString", (object)method.Name);
}
}
}
/// <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);
}
protected override object MethodInvoke(PSMethod method, object[] arguments)
{
object[] objArray;
Exception exception = null;
ParameterInformation[] informationArray = new ParameterInformation[arguments.Length];
for (int i = 0; i < arguments.Length; i++)
{
informationArray[i] = new ParameterInformation(typeof(object), false, null, false);
}
MethodInformation[] methods = new MethodInformation[] { new MethodInformation(false, false, informationArray) };
Adapter.GetBestMethodAndArguments(method.Name, methods, arguments, out objArray);
DirectoryEntry baseObject = (DirectoryEntry)method.baseObject;
try
{
return(baseObject.Invoke(method.Name, objArray));
}
#if !MONO
catch (DirectoryServicesCOMException exception2)
{
exception = exception2;
}
#endif
catch (TargetInvocationException exception3)
{
exception = exception3;
}
catch (COMException exception4)
{
exception = exception4;
}
PSMethod dotNetMethod = dotNetAdapter.GetDotNetMethod <PSMethod>(method.baseObject, method.name);
if (dotNetMethod == null)
{
throw exception;
}
return(dotNetMethod.Invoke(arguments));
}
/// <summary>
/// Returns the first PSMemberInfo whose name matches the specified <see cref="MemberNamePredicate"/>.
/// </summary>
protected override T GetFirstMemberOrDefault <T>(object obj, MemberNamePredicate predicate)
{
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 &&
lookingForParameterizedProperties &&
predicate(prop.Name))
{
return(new PSParameterizedProperty(prop.Name, this, obj, prop) as T);
}
if (lookingForProperties && predicate(prop.Name))
{
return(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 (predicate(method.Name))
{
var mshMethod = new PSMethod(method.Name, this, obj, method);
return(mshMethod as T);
}
}
}
return(null);
}
internal object InvokeMethod(PSMethod method, object[] arguments)
{
Type type = method.baseObject.GetType();
BindingFlags invokeAttr = BindingFlags.InvokeMethod | BindingFlags.IgnoreCase;
try
{
object[] objArray;
ComMethodInformation[] informationArray = ComUtil.GetMethodInformationArray(this.typeInfo, this.methods, false);
ComMethodInformation methodInformation = (ComMethodInformation)Adapter.GetBestMethodAndArguments(this.Name, (MethodInformation[])informationArray, arguments, out objArray);
object obj2 = type.InvokeMember(this.Name, invokeAttr, null, method.baseObject, objArray, ComUtil.GetModifiers(methodInformation.parameters), CultureInfo.CurrentCulture, null);
Adapter.SetReferences(objArray, methodInformation, arguments);
if (methodInformation.ReturnType != typeof(void))
{
return(obj2);
}
return(AutomationNull.Value);
}
catch (TargetInvocationException exception)
{
CommandProcessorBase.CheckForSevereException(exception.InnerException);
COMException innerException = exception.InnerException as COMException;
if ((innerException == null) || (innerException.ErrorCode != -2147352573))
{
string str = (exception.InnerException == null) ? exception.Message : exception.InnerException.Message;
throw new MethodInvocationException("ComMethodTargetInvocation", exception, ExtendedTypeSystem.MethodInvocationException, new object[] { method.Name, arguments.Length, str });
}
}
catch (COMException exception3)
{
if (exception3.ErrorCode != -2147352570)
{
throw new MethodInvocationException("ComMethodCOMException", exception3, ExtendedTypeSystem.MethodInvocationException, new object[] { method.Name, arguments.Length, exception3.Message });
}
}
return(null);
}
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);
}
internal object InvokeMethod(PSMethod method, object[] arguments)
{
Type type = method.baseObject.GetType();
BindingFlags invokeAttr = BindingFlags.InvokeMethod | BindingFlags.IgnoreCase;
try
{
object[] objArray;
ComMethodInformation[] informationArray = ComUtil.GetMethodInformationArray(this.typeInfo, this.methods, false);
ComMethodInformation methodInformation = (ComMethodInformation) Adapter.GetBestMethodAndArguments(this.Name, (MethodInformation[]) informationArray, arguments, out objArray);
object obj2 = type.InvokeMember(this.Name, invokeAttr, null, method.baseObject, objArray, ComUtil.GetModifiers(methodInformation.parameters), CultureInfo.CurrentCulture, null);
Adapter.SetReferences(objArray, methodInformation, arguments);
if (methodInformation.ReturnType != typeof(void))
{
return obj2;
}
return AutomationNull.Value;
}
catch (TargetInvocationException exception)
{
CommandProcessorBase.CheckForSevereException(exception.InnerException);
COMException innerException = exception.InnerException as COMException;
if ((innerException == null) || (innerException.ErrorCode != -2147352573))
{
string str = (exception.InnerException == null) ? exception.Message : exception.InnerException.Message;
throw new MethodInvocationException("ComMethodTargetInvocation", exception, ExtendedTypeSystem.MethodInvocationException, new object[] { method.Name, arguments.Length, str });
}
}
catch (COMException exception3)
{
if (exception3.ErrorCode != -2147352570)
{
throw new MethodInvocationException("ComMethodCOMException", exception3, ExtendedTypeSystem.MethodInvocationException, new object[] { method.Name, arguments.Length, exception3.Message });
}
}
return null;
}
protected override Collection<string> MethodDefinitions(PSMethod method)
{
throw PSTraceSource.NewNotSupportedException();
}
protected override Collection <string> MethodDefinitions(PSMethod method)
{
ComMethod adapterData = (ComMethod)method.adapterData;
return(adapterData.MethodDefinitions());
}
protected override object MethodInvoke(PSMethod method, object[] arguments)
{
throw PSTraceSource.NewNotSupportedException();
}
protected override object MethodInvoke(PSMethod method, PSMethodInvocationConstraints invocationConstraints, object[] arguments)
{
return(this.MethodInvoke(method, arguments));
}
protected abstract Collection <string> MethodDefinitions(PSMethod method);
public override PSMemberInfo Copy()
{
PSMethod destiny = new PSMethod(base.name, this.adapter, this.baseObject, this.adapterData, this.isSpecial);
base.CloneBaseProperties(destiny);
return destiny;
}
/// <summary>
/// Called after a non null return from GetMethodData to try to call
/// the method with the arguments
/// </summary>
/// <param name="method">the non empty return from GetMethods</param>
/// <param name="arguments">the arguments to use</param>
/// <returns>the return value for the method</returns>
protected override object MethodInvoke(PSMethod method, object[] arguments)
{
ComMethod commethod = (ComMethod)method.adapterData;
return(commethod.InvokeMethod(method, arguments));
}
/// <summary>
/// Invokes the method on object
/// </summary>
/// <param name="method">represents the instance of the method we want to invoke</param>
/// <param name="arguments">parameters to be passed to the method</param>
/// <returns>returns the value of method call</returns>
internal object InvokeMethod(PSMethod method, object[] arguments)
{
try
{
object[] newarguments;
var methods = ComUtil.GetMethodInformationArray(_typeInfo, _methods, false);
var bestMethod = (ComMethodInformation)Adapter.GetBestMethodAndArguments(Name, methods, arguments, out newarguments);
object returnValue = ComInvoker.Invoke(method.baseObject as IDispatch,
bestMethod.DispId, newarguments,
ComInvoker.GetByRefArray(bestMethod.parameters,
newarguments.Length,
isPropertySet: false),
COM.INVOKEKIND.INVOKE_FUNC);
Adapter.SetReferences(newarguments, bestMethod, arguments);
return bestMethod.ReturnType != typeof(void) ? returnValue : AutomationNull.Value;
}
catch (TargetInvocationException te)
{
//First check if this is a severe exception.
CommandProcessorBase.CheckForSevereException(te.InnerException);
var innerCom = te.InnerException as COMException;
if (innerCom == null || innerCom.HResult != ComUtil.DISP_E_MEMBERNOTFOUND)
{
string message = te.InnerException == null ? te.Message : te.InnerException.Message;
throw new MethodInvocationException(
"ComMethodTargetInvocation",
te,
ExtendedTypeSystem.MethodInvocationException,
method.Name, arguments.Length, message);
}
}
catch (COMException ce)
{
if (ce.HResult != ComUtil.DISP_E_UNKNOWNNAME)
{
throw new MethodInvocationException(
"ComMethodCOMException",
ce,
ExtendedTypeSystem.MethodInvocationException,
method.Name, arguments.Length, ce.Message);
}
}
return null;
}
protected override Collection <string> MethodDefinitions(PSMethod method) => new Collection <string>()
{
((BaseWMIAdapter.WMIMethodCacheEntry)method.adapterData).MethodDefinition
};
protected override object MethodInvoke(PSMethod method, object[] arguments) => this.AuxillaryInvokeMethod(method.baseObject as ManagementObject, (BaseWMIAdapter.WMIMethodCacheEntry)method.adapterData, arguments);
/// <summary>
/// Called after a non null return from GetMethodData to return the overloads
/// </summary>
/// <param name="method">the return of GetMethodData</param>
/// <returns></returns>
protected override Collection <String> MethodDefinitions(PSMethod method)
{
ComMethod commethod = (ComMethod)method.adapterData;
return(commethod.MethodDefinitions());
}