Ejemplo n.º 1
0
        /// <summary>
        /// Obtains the parameter information for a given FuncDesc.
        /// </summary>
        internal static ParameterInformation[] GetParameterInformation(COM.FUNCDESC funcdesc, bool skipLastParameter)
        {
            int cParams = funcdesc.cParams;

            if (skipLastParameter)
            {
                Diagnostics.Assert(cParams > 0, "skipLastParameter is only true for property setters where there is at least one parameter");
                cParams--;
            }

            ParameterInformation[] parameters = new ParameterInformation[cParams];

            IntPtr ElementDescriptionArrayPtr = funcdesc.lprgelemdescParam;
            int    ElementDescriptionSize     = Marshal.SizeOf <COM.ELEMDESC>();

            for (int i = 0; i < cParams; i++)
            {
                COM.ELEMDESC ElementDescription;
                int          ElementDescriptionArrayByteOffset;
                IntPtr       ElementDescriptionPointer;
                bool         fOptional = false;

                ElementDescription = new COM.ELEMDESC();
                ElementDescriptionArrayByteOffset = i * ElementDescriptionSize;
                // Disable PRefast warning for converting to int32 and converting back into intptr.
                // Code below takes into account 32 bit vs 64 bit conversions
#pragma warning disable 56515

                if (IntPtr.Size == 4)
                {
                    ElementDescriptionPointer = (IntPtr)(ElementDescriptionArrayPtr.ToInt32() + ElementDescriptionArrayByteOffset);
                }
                else
                {
                    ElementDescriptionPointer = (IntPtr)(ElementDescriptionArrayPtr.ToInt64() + ElementDescriptionArrayByteOffset);
                }

#pragma warning enable 56515

                ElementDescription = Marshal.PtrToStructure <COM.ELEMDESC>(ElementDescriptionPointer);

                // get the type of parameter
                Type   type         = ComUtil.GetTypeFromTypeDesc(ElementDescription.tdesc);
                object defaultvalue = null;

                // check is this parameter is optional.
                if ((ElementDescription.desc.paramdesc.wParamFlags & COM.PARAMFLAG.PARAMFLAG_FOPT) != 0)
                {
                    fOptional    = true;
                    defaultvalue = Type.Missing;
                }

                bool fByRef = (ElementDescription.desc.paramdesc.wParamFlags & COM.PARAMFLAG.PARAMFLAG_FOUT) != 0;
                parameters[i] = new ParameterInformation(type, fOptional, defaultvalue, fByRef);
            }

            return(parameters);
        }
Ejemplo n.º 2
0
        internal Collection <string> MethodDefinitions()
        {
            Collection <string> collection = new Collection <string>();

            foreach (int method in this.methods)
            {
                IntPtr ppFuncDesc;
                this.typeInfo.GetFuncDesc(method, out ppFuncDesc);
                string signatureFromFuncDesc = ComUtil.GetMethodSignatureFromFuncDesc(this.typeInfo, (System.Runtime.InteropServices.ComTypes.FUNCDESC)Marshal.PtrToStructure(ppFuncDesc, typeof(System.Runtime.InteropServices.ComTypes.FUNCDESC)), false);
                collection.Add(signatureFromFuncDesc);
                this.typeInfo.ReleaseFuncDesc(ppFuncDesc);
            }
            return(collection);
        }
Ejemplo n.º 3
0
        internal Collection <string> MethodDefinitions()
        {
            Collection <string> collection = new Collection <string>();

            foreach (int num in this.methods)
            {
                IntPtr ptr;
                this.typeInfo.GetFuncDesc(num, out ptr);
                System.Runtime.InteropServices.ComTypes.FUNCDESC funcdesc = (System.Runtime.InteropServices.ComTypes.FUNCDESC)Marshal.PtrToStructure(ptr, typeof(System.Runtime.InteropServices.ComTypes.FUNCDESC));
                string item = ComUtil.GetMethodSignatureFromFuncDesc(this.typeInfo, funcdesc, false);
                collection.Add(item);
                this.typeInfo.ReleaseFuncDesc(ptr);
            }
            return(collection);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Sets the value of the property.
        /// </summary>
        /// <param name="target">instance of the object to which to set the property value</param>
        /// <param name="setValue">value to set this property</param>
        /// <param name="arguments">parameters to set this property.</param>
        internal void SetValue(Object target, Object setValue, Object[] arguments)
        {
            object[] newarguments;
            var      setterCollection = new Collection <int> {
                _hasSetterByRef?_setterByRefIndex : _setterIndex
            };
            var methods    = ComUtil.GetMethodInformationArray(_typeInfo, setterCollection, true);
            var bestMethod = (ComMethodInformation)Adapter.GetBestMethodAndArguments(Name, methods, arguments, out newarguments);

            var finalArguments = new object[newarguments.Length + 1];

            for (int i = 0; i < newarguments.Length; i++)
            {
                finalArguments[i] = newarguments[i];
            }
            finalArguments[newarguments.Length] = Adapter.PropertySetAndMethodArgumentConvertTo(setValue, Type, CultureInfo.InvariantCulture);

            try
            {
                ComInvoker.Invoke(target as IDispatch,
                                  bestMethod.DispId,
                                  finalArguments,
                                  ComInvoker.GetByRefArray(bestMethod.parameters,
                                                           finalArguments.Length,
                                                           isPropertySet: true),
                                  bestMethod.InvokeKind);
                Adapter.SetReferences(finalArguments, bestMethod, arguments);
            }
            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)
                {
                    throw;
                }
            }
            catch (COMException ce)
            {
                if (ce.HResult != ComUtil.DISP_E_UNKNOWNNAME)
                {
                    throw;
                }
            }
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Converts a MethodBase[] into a MethodInformation[]
        /// </summary>
        /// <returns>the ComMethodInformation[] corresponding to methods</returns>
        internal static ComMethodInformation[] GetMethodInformationArray(COM.ITypeInfo typeInfo, Collection <int> methods, bool skipLastParameters)
        {
            int methodCount = methods.Count;
            int count       = 0;

            ComMethodInformation[] returnValue = new ComMethodInformation[methodCount];

            foreach (int index in methods)
            {
                IntPtr pFuncDesc;
                typeInfo.GetFuncDesc(index, out pFuncDesc);
                COM.FUNCDESC funcdesc = ClrFacade.PtrToStructure <COM.FUNCDESC>(pFuncDesc);
                returnValue[count++] = ComUtil.GetMethodInformation(funcdesc, skipLastParameters);
                typeInfo.ReleaseFuncDesc(pFuncDesc);
            }
            return(returnValue);
        }
Ejemplo n.º 6
0
        internal string GetDefinition()
        {
            IntPtr ppFuncDesc = IntPtr.Zero;

            try
            {
                this.typeInfo.GetFuncDesc(this.GetFuncDescIndex(), out ppFuncDesc);
                return(ComUtil.GetMethodSignatureFromFuncDesc(this.typeInfo, (System.Runtime.InteropServices.ComTypes.FUNCDESC)Marshal.PtrToStructure(ppFuncDesc, typeof(System.Runtime.InteropServices.ComTypes.FUNCDESC)), !this.hasGetter));
            }
            finally
            {
                if (ppFuncDesc != IntPtr.Zero)
                {
                    this.typeInfo.ReleaseFuncDesc(ppFuncDesc);
                }
            }
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Initializes the typeinfo object.
        /// </summary>
        private void Initialize()
        {
            if (_typeinfo != null)
            {
                COM.TYPEATTR typeattr = GetTypeAttr(_typeinfo);

                // Initialize the type information guid
                _guid = typeattr.guid;

                for (int i = 0; i < typeattr.cFuncs; i++)
                {
                    COM.FUNCDESC funcdesc = GetFuncDesc(_typeinfo, i);
                    if (funcdesc.memid == DISPID_NEWENUM)
                    {
                        NewEnumInvokeKind = funcdesc.invkind;
                    }

                    if ((funcdesc.wFuncFlags & 0x1) == 0x1)
                    {
                        // https://msdn.microsoft.com/library/ee488948.aspx
                        // FUNCFLAGS -- FUNCFLAG_FRESTRICTED = 0x1:
                        //     Indicates that the function should not be accessible from macro languages.
                        //     This flag is intended for system-level functions or functions that type browsers should not display.
                        //
                        // For IUnknown methods (AddRef, QueryInterface and Release) and IDispatch methods (GetTypeInfoCount, GetTypeInfo, GetIDsOfNames and Invoke)
                        // FUNCFLAG_FRESTRICTED (0x1) is set for the 'wFuncFlags' field
                        continue;
                    }

                    string strName = ComUtil.GetNameFromFuncDesc(_typeinfo, funcdesc);

                    switch (funcdesc.invkind)
                    {
                    case COM.INVOKEKIND.INVOKE_PROPERTYGET:
                    case COM.INVOKEKIND.INVOKE_PROPERTYPUT:
                    case COM.INVOKEKIND.INVOKE_PROPERTYPUTREF:
                        AddProperty(strName, funcdesc, i);
                        break;

                    case COM.INVOKEKIND.INVOKE_FUNC:
                        AddMethod(strName, i);
                        break;
                    }
                }
            }
        }
Ejemplo n.º 8
0
        /// <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);
        }
Ejemplo n.º 9
0
        internal static ComMethodInformation[] GetMethodInformationArray(
            ITypeInfo typeInfo,
            Collection <int> methods,
            bool skipLastParameters)
        {
            int count = methods.Count;
            int num   = 0;

            ComMethodInformation[] methodInformationArray = new ComMethodInformation[count];
            foreach (int method in methods)
            {
                IntPtr ppFuncDesc;
                typeInfo.GetFuncDesc(method, out ppFuncDesc);
                System.Runtime.InteropServices.ComTypes.FUNCDESC structure = (System.Runtime.InteropServices.ComTypes.FUNCDESC)Marshal.PtrToStructure(ppFuncDesc, typeof(System.Runtime.InteropServices.ComTypes.FUNCDESC));
                methodInformationArray[num++] = ComUtil.GetMethodInformation(structure, skipLastParameters);
                typeInfo.ReleaseFuncDesc(ppFuncDesc);
            }
            return(methodInformationArray);
        }
Ejemplo n.º 10
0
        internal string GetDefinition()
        {
            IntPtr pFuncDesc = IntPtr.Zero;

            try
            {
                _typeInfo.GetFuncDesc(GetFuncDescIndex(), out pFuncDesc);
                COM.FUNCDESC funcdesc = Marshal.PtrToStructure <COM.FUNCDESC>(pFuncDesc);

                return(ComUtil.GetMethodSignatureFromFuncDesc(_typeInfo, funcdesc, !IsGettable));
            }
            finally
            {
                if (pFuncDesc != IntPtr.Zero)
                {
                    _typeInfo.ReleaseFuncDesc(pFuncDesc);
                }
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Returns the different method overloads signatures.
        /// </summary>
        /// <returns></returns>
        internal Collection <string> MethodDefinitions()
        {
            Collection <string> result = new Collection <string>();

            foreach (int index in _methods)
            {
                IntPtr pFuncDesc;

                _typeInfo.GetFuncDesc(index, out pFuncDesc);
                COM.FUNCDESC funcdesc = Marshal.PtrToStructure <COM.FUNCDESC>(pFuncDesc);

                string signature = ComUtil.GetMethodSignatureFromFuncDesc(_typeInfo, funcdesc, false);
                result.Add(signature);

                _typeInfo.ReleaseFuncDesc(pFuncDesc);
            }

            return(result);
        }
Ejemplo n.º 12
0
        private static ComMethodInformation GetMethodInformation(
            System.Runtime.InteropServices.ComTypes.FUNCDESC funcdesc,
            bool skipLastParameter)
        {
            Type typeFromTypeDesc = ComUtil.GetTypeFromTypeDesc(funcdesc.elemdescFunc.tdesc);

            ParameterInformation[] parameterInformation1 = ComUtil.GetParameterInformation(funcdesc, skipLastParameter);
            bool hasoptional = false;

            foreach (ParameterInformation parameterInformation2 in parameterInformation1)
            {
                if (parameterInformation2.isOptional)
                {
                    hasoptional = true;
                    break;
                }
            }
            return(new ComMethodInformation(false, hasoptional, parameterInformation1, typeFromTypeDesc));
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Get value of this property
        /// </summary>
        /// <param name="target">instance of the object from which to get the property value</param>
        /// <param name="arguments">parameters to get the property value</param>
        /// <returns>value of the property</returns>
        internal object GetValue(Object target, Object[] arguments)
        {
            try
            {
                object[] newarguments;
                var      getterCollection = new Collection <int> {
                    _getterIndex
                };
                var methods    = ComUtil.GetMethodInformationArray(_typeInfo, getterCollection, false);
                var bestMethod = (ComMethodInformation)Adapter.GetBestMethodAndArguments(Name, methods, arguments, out newarguments);

                object returnValue = ComInvoker.Invoke(target as IDispatch,
                                                       bestMethod.DispId,
                                                       newarguments,
                                                       ComInvoker.GetByRefArray(bestMethod.parameters,
                                                                                newarguments.Length,
                                                                                isPropertySet: false),
                                                       bestMethod.InvokeKind);
                Adapter.SetReferences(newarguments, bestMethod, arguments);
                return(returnValue);
            }
            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)
                {
                    throw;
                }
            }
            catch (COMException ce)
            {
                if (ce.HResult != ComUtil.DISP_E_UNKNOWNNAME)
                {
                    throw;
                }
            }

            return(null);
        }
Ejemplo n.º 14
0
        internal string GetDefinition()
        {
            string str;
            IntPtr zero = IntPtr.Zero;

            try
            {
                this.typeInfo.GetFuncDesc(this.GetFuncDescIndex(), out zero);
                System.Runtime.InteropServices.ComTypes.FUNCDESC funcdesc = (System.Runtime.InteropServices.ComTypes.FUNCDESC)Marshal.PtrToStructure(zero, typeof(System.Runtime.InteropServices.ComTypes.FUNCDESC));
                str = ComUtil.GetMethodSignatureFromFuncDesc(this.typeInfo, funcdesc, !this.hasGetter);
            }
            finally
            {
                if (zero != IntPtr.Zero)
                {
                    this.typeInfo.ReleaseFuncDesc(zero);
                }
            }
            return(str);
        }
Ejemplo n.º 15
0
        internal static string GetMethodSignatureFromFuncDesc(
            ITypeInfo typeinfo,
            System.Runtime.InteropServices.ComTypes.FUNCDESC funcdesc,
            bool isPropertyPut)
        {
            StringBuilder stringBuilder    = new StringBuilder();
            string        nameFromFuncDesc = ComUtil.GetNameFromFuncDesc(typeinfo, funcdesc);

            if (!isPropertyPut)
            {
                string stringFromTypeDesc = ComUtil.GetStringFromTypeDesc(typeinfo, funcdesc.elemdescFunc.tdesc);
                stringBuilder.Append(stringFromTypeDesc + " ");
            }
            stringBuilder.Append(nameFromFuncDesc);
            stringBuilder.Append(" (");
            IntPtr lprgelemdescParam = funcdesc.lprgelemdescParam;
            int    num1 = Marshal.SizeOf(typeof(System.Runtime.InteropServices.ComTypes.ELEMDESC));

            for (int index = 0; index < (int)funcdesc.cParams; ++index)
            {
                System.Runtime.InteropServices.ComTypes.ELEMDESC elemdesc = new System.Runtime.InteropServices.ComTypes.ELEMDESC();
                int num2 = index * num1;
                elemdesc = (System.Runtime.InteropServices.ComTypes.ELEMDESC)Marshal.PtrToStructure(IntPtr.Size != 4 ? (IntPtr)(lprgelemdescParam.ToInt64() + (long)num2) : (IntPtr)(lprgelemdescParam.ToInt32() + num2), typeof(System.Runtime.InteropServices.ComTypes.ELEMDESC));
                string stringFromTypeDesc = ComUtil.GetStringFromTypeDesc(typeinfo, elemdesc.tdesc);
                if (index == 0 && isPropertyPut)
                {
                    stringBuilder.Insert(0, stringFromTypeDesc + " ");
                }
                else
                {
                    stringBuilder.Append(stringFromTypeDesc);
                    if (index < (int)funcdesc.cParams - 1)
                    {
                        stringBuilder.Append(", ");
                    }
                }
            }
            stringBuilder.Append(")");
            return(stringBuilder.ToString());
        }
Ejemplo n.º 16
0
        internal static ParameterInformation[] GetParameterInformation(
            System.Runtime.InteropServices.ComTypes.FUNCDESC funcdesc,
            bool skipLastParameter)
        {
            int cParams = (int)funcdesc.cParams;

            if (skipLastParameter)
            {
                --cParams;
            }
            ParameterInformation[] parameterInformationArray = new ParameterInformation[cParams];
            IntPtr lprgelemdescParam = funcdesc.lprgelemdescParam;
            int    num1 = Marshal.SizeOf(typeof(System.Runtime.InteropServices.ComTypes.ELEMDESC));

            for (int index = 0; index < cParams; ++index)
            {
                System.Runtime.InteropServices.ComTypes.ELEMDESC elemdesc = new System.Runtime.InteropServices.ComTypes.ELEMDESC();
                int num2 = index * num1;
                elemdesc = (System.Runtime.InteropServices.ComTypes.ELEMDESC)Marshal.PtrToStructure(IntPtr.Size != 4 ? (IntPtr)(lprgelemdescParam.ToInt64() + (long)num2) : (IntPtr)(lprgelemdescParam.ToInt32() + num2), typeof(System.Runtime.InteropServices.ComTypes.ELEMDESC));
                Type   typeFromTypeDesc = ComUtil.GetTypeFromTypeDesc(elemdesc.tdesc);
                object defaultValue     = (object)null;
                bool   isOptional;
                if ((elemdesc.desc.paramdesc.wParamFlags & System.Runtime.InteropServices.ComTypes.PARAMFLAG.PARAMFLAG_FOPT) != System.Runtime.InteropServices.ComTypes.PARAMFLAG.PARAMFLAG_NONE)
                {
                    isOptional   = true;
                    defaultValue = Type.Missing;
                }
                else
                {
                    isOptional = false;
                }
                bool isByRef = false;
                if ((elemdesc.desc.paramdesc.wParamFlags & System.Runtime.InteropServices.ComTypes.PARAMFLAG.PARAMFLAG_FOUT) != System.Runtime.InteropServices.ComTypes.PARAMFLAG.PARAMFLAG_NONE)
                {
                    isByRef = true;
                }
                parameterInformationArray[index] = new ParameterInformation(typeFromTypeDesc, isOptional, defaultValue, isByRef);
            }
            return(parameterInformationArray);
        }
Ejemplo n.º 17
0
        internal void SetValue(object target, object setValue, object[] arguments)
        {
            object[]         objArray;
            Collection <int> methods = new Collection <int> {
                (this.hasSetterByRef != null) ? this.setterByRefIndex : this.setterIndex
            };

            MethodInformation[] informationArray  = ComUtil.GetMethodInformationArray(this.typeInfo, methods, true);
            MethodInformation   methodInformation = Adapter.GetBestMethodAndArguments(this.Name, informationArray, arguments, out objArray);

            System.Type type = target.GetType();
            object[]    args = new object[objArray.Length + 1];
            for (int i = 0; i < objArray.Length; i++)
            {
                args[i] = objArray[i];
            }
            args[objArray.Length] = Adapter.PropertySetAndMethodArgumentConvertTo(setValue, this.Type, CultureInfo.InvariantCulture);
            try
            {
                type.InvokeMember(this.name, BindingFlags.SetProperty | BindingFlags.IgnoreCase, null, target, args, ComUtil.GetModifiers(methodInformation.parameters), CultureInfo.CurrentCulture, null);
                Adapter.SetReferences(args, methodInformation, arguments);
            }
            catch (TargetInvocationException exception)
            {
                CommandProcessorBase.CheckForSevereException(exception.InnerException);
                COMException innerException = exception.InnerException as COMException;
                if ((innerException == null) || (innerException.ErrorCode != -2147352573))
                {
                    throw;
                }
            }
            catch (COMException exception3)
            {
                if (exception3.ErrorCode != -2147352570)
                {
                    throw;
                }
            }
        }
Ejemplo n.º 18
0
        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);
        }
Ejemplo n.º 19
0
        private static string GetStringFromTypeDesc(ITypeInfo typeinfo, System.Runtime.InteropServices.ComTypes.TYPEDESC typedesc)
        {
            if (typedesc.vt == (short)26)
            {
                System.Runtime.InteropServices.ComTypes.TYPEDESC structure = (System.Runtime.InteropServices.ComTypes.TYPEDESC)Marshal.PtrToStructure(typedesc.lpValue, typeof(System.Runtime.InteropServices.ComTypes.TYPEDESC));
                return(ComUtil.GetStringFromTypeDesc(typeinfo, structure));
            }
            if (typedesc.vt == (short)27)
            {
                System.Runtime.InteropServices.ComTypes.TYPEDESC structure = (System.Runtime.InteropServices.ComTypes.TYPEDESC)Marshal.PtrToStructure(typedesc.lpValue, typeof(System.Runtime.InteropServices.ComTypes.TYPEDESC));
                return("SAFEARRAY(" + ComUtil.GetStringFromTypeDesc(typeinfo, structure) + ")");
            }
            if (typedesc.vt == (short)29)
            {
                return(ComUtil.GetStringFromCustomType(typeinfo, typedesc.lpValue));
            }
            switch ((VarEnum)typedesc.vt)
            {
            case VarEnum.VT_EMPTY:
                return("");

            case VarEnum.VT_I2:
                return("short");

            case VarEnum.VT_I4:
            case VarEnum.VT_INT:
            case VarEnum.VT_HRESULT:
                return("int");

            case VarEnum.VT_R4:
                return("float");

            case VarEnum.VT_R8:
                return("double");

            case VarEnum.VT_CY:
                return("currency");

            case VarEnum.VT_DATE:
                return("Date");

            case VarEnum.VT_BSTR:
            case VarEnum.VT_LPSTR:
            case VarEnum.VT_LPWSTR:
                return("string");

            case VarEnum.VT_DISPATCH:
                return("IDispatch");

            case VarEnum.VT_BOOL:
                return("bool");

            case VarEnum.VT_VARIANT:
                return("Variant");

            case VarEnum.VT_UNKNOWN:
                return("IUnknown");

            case VarEnum.VT_DECIMAL:
                return("decimal");

            case VarEnum.VT_I1:
                return("char");

            case VarEnum.VT_UI1:
                return("byte");

            case VarEnum.VT_UI2:
                return("ushort");

            case VarEnum.VT_UI4:
            case VarEnum.VT_UINT:
                return("uint");

            case VarEnum.VT_I8:
                return("int64");

            case VarEnum.VT_UI8:
                return("uint64");

            case VarEnum.VT_VOID:
                return("void");

            case VarEnum.VT_CLSID:
                return("clsid");

            case VarEnum.VT_ARRAY:
                return("object[]");

            default:
                return("Unknown!");
            }
        }
Ejemplo n.º 20
0
 internal void SetValue(object target, object setValue, object[] arguments)
 {
     using (ComProperty.tracer.TraceMethod())
     {
         object[]          newArguments;
         MethodInformation methodAndArguments = Adapter.GetBestMethodAndArguments(this.Name, (MethodInformation[])ComUtil.GetMethodInformationArray(this.typeInfo, new Collection <int>()
         {
             this.hasSetterByRef ? this.setterByRefIndex : this.setterIndex
         }, true), arguments, out newArguments);
         Type     type     = target.GetType();
         object[] objArray = new object[newArguments.Length + 1];
         for (int index = 0; index < newArguments.Length; ++index)
         {
             objArray[index] = newArguments[index];
         }
         objArray[newArguments.Length] = Adapter.PropertySetAndMethodArgumentConvertTo(setValue, this.Type, (IFormatProvider)CultureInfo.InvariantCulture);
         try
         {
             type.InvokeMember(this.name, BindingFlags.IgnoreCase | BindingFlags.SetProperty, (Binder)null, target, objArray, ComUtil.GetModifiers(methodAndArguments.parameters), CultureInfo.CurrentCulture, (string[])null);
             Adapter.SetReferences(objArray, methodAndArguments, arguments);
         }
         catch (TargetInvocationException ex)
         {
             CommandProcessorBase.CheckForSevereException(ex.InnerException);
             if (ex.InnerException is COMException innerException && innerException.ErrorCode == -2147352573)
             {
                 return;
             }
             throw;
         }
         catch (COMException ex)
         {
             if (ex.ErrorCode == -2147352570)
             {
                 return;
             }
             throw;
         }
     }
 }
Ejemplo n.º 21
0
        internal object GetValue(object target, object[] arguments)
        {
            using (ComProperty.tracer.TraceMethod())
            {
                Type type = target.GetType();
                try
                {
                    object[]          newArguments;
                    MethodInformation methodAndArguments = Adapter.GetBestMethodAndArguments(this.Name, (MethodInformation[])ComUtil.GetMethodInformationArray(this.typeInfo, new Collection <int>()
                    {
                        this.getterIndex
                    }, false), arguments, out newArguments);
                    object obj = type.InvokeMember(this.name, BindingFlags.IgnoreCase | BindingFlags.GetProperty, (Binder)null, target, newArguments, ComUtil.GetModifiers(methodAndArguments.parameters), CultureInfo.CurrentCulture, (string[])null);
                    Adapter.SetReferences(newArguments, methodAndArguments, arguments);
                    return(obj);
                }
                catch (TargetInvocationException ex)
                {
                    CommandProcessorBase.CheckForSevereException(ex.InnerException);
                    if (ex.InnerException is COMException innerException)
                    {
                        if (innerException.ErrorCode == -2147352573)
                        {
                            goto label_8;
                        }
                    }
                    throw;
                }
                catch (COMException ex)
                {
                    if (ex.ErrorCode != -2147352570)
                    {
                        throw;
                    }
                }
label_8:
                return((object)null);
            }
        }
Ejemplo n.º 22
0
        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);
        }
Ejemplo n.º 23
0
 internal object GetValue(object target, object[] arguments)
 {
     System.Type type = target.GetType();
     try
     {
         object[]         objArray;
         Collection <int> methods = new Collection <int> {
             this.getterIndex
         };
         MethodInformation[] informationArray  = ComUtil.GetMethodInformationArray(this.typeInfo, methods, false);
         MethodInformation   methodInformation = Adapter.GetBestMethodAndArguments(this.Name, informationArray, arguments, out objArray);
         object obj2 = type.InvokeMember(this.name, BindingFlags.GetProperty | BindingFlags.IgnoreCase, null, target, objArray, ComUtil.GetModifiers(methodInformation.parameters), CultureInfo.CurrentCulture, null);
         Adapter.SetReferences(objArray, methodInformation, arguments);
         return(obj2);
     }
     catch (TargetInvocationException exception)
     {
         CommandProcessorBase.CheckForSevereException(exception.InnerException);
         COMException innerException = exception.InnerException as COMException;
         if ((innerException == null) || (innerException.ErrorCode != -2147352573))
         {
             throw;
         }
     }
     catch (COMException exception3)
     {
         if (exception3.ErrorCode != -2147352570)
         {
             throw;
         }
     }
     return(null);
 }