mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
557 lines
23 KiB
C#
557 lines
23 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
namespace System.ServiceModel.ComIntegration
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime;
|
|
using System.Runtime.InteropServices;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Dispatcher;
|
|
|
|
class DispatchProxy : IPseudoDispatch, IDisposable
|
|
{
|
|
ContractDescription contract;
|
|
IProvideChannelBuilderSettings channelBuilderSettings;
|
|
Dictionary<UInt32, string> dispToName = new Dictionary<UInt32, string>();
|
|
Dictionary<string, UInt32> nameToDisp = new Dictionary<string, UInt32>();
|
|
Dictionary<UInt32, MethodInfo> dispToOperationDescription = new Dictionary<UInt32, MethodInfo>();
|
|
|
|
private DispatchProxy(ContractDescription contract, IProvideChannelBuilderSettings channelBuilderSettings)
|
|
{
|
|
if (channelBuilderSettings == null)
|
|
{
|
|
throw Fx.AssertAndThrow("channelBuilderSettings cannot be null cannot be null");
|
|
}
|
|
if (contract == null)
|
|
{
|
|
throw Fx.AssertAndThrow("contract cannot be null");
|
|
}
|
|
this.channelBuilderSettings = channelBuilderSettings;
|
|
this.contract = contract;
|
|
ProcessContractDescription();
|
|
ComPlusDispatchMethodTrace.Trace(TraceEventType.Verbose, TraceCode.ComIntegrationDispatchMethod,
|
|
SR.TraceCodeComIntegrationDispatchMethod, dispToOperationDescription);
|
|
}
|
|
|
|
internal static ComProxy Create(IntPtr outer, ContractDescription contract, IProvideChannelBuilderSettings channelBuilderSettings)
|
|
{
|
|
DispatchProxy proxy = null;
|
|
IntPtr inner = IntPtr.Zero;
|
|
ComProxy comProxy = null;
|
|
try
|
|
{
|
|
proxy = new DispatchProxy(contract, channelBuilderSettings);
|
|
inner = OuterProxyWrapper.CreateDispatchProxy(outer, proxy);
|
|
comProxy = new ComProxy(inner, proxy);
|
|
return comProxy;
|
|
|
|
}
|
|
finally
|
|
{
|
|
if (comProxy == null)
|
|
{
|
|
if (proxy != null)
|
|
{
|
|
((IDisposable)proxy).Dispose();
|
|
}
|
|
if (inner != IntPtr.Zero)
|
|
{
|
|
Marshal.Release(inner);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
[Serializable]
|
|
internal class ParamInfo
|
|
{
|
|
public int inIndex;
|
|
public int outIndex;
|
|
public string name;
|
|
public Type type;
|
|
public ParamInfo()
|
|
{
|
|
inIndex = -1;
|
|
outIndex = -1;
|
|
}
|
|
}
|
|
|
|
|
|
internal class MethodInfo
|
|
{
|
|
public OperationDescription opDesc;
|
|
public List<ParamInfo> paramList;
|
|
public Dictionary<uint, ParamInfo> dispIdToParamInfo;
|
|
public ParamInfo ReturnVal = null;
|
|
public MethodInfo(OperationDescription opDesc)
|
|
{
|
|
this.opDesc = opDesc;
|
|
paramList = new List<ParamInfo>();
|
|
dispIdToParamInfo = new Dictionary<uint, ParamInfo>();
|
|
}
|
|
}
|
|
|
|
void ProcessContractDescription()
|
|
{
|
|
UInt32 dispIndex = 10;
|
|
Dictionary<string, ParamInfo> paramDictionary = null;
|
|
|
|
foreach (OperationDescription opDesc in contract.Operations)
|
|
{
|
|
dispToName[dispIndex] = opDesc.Name;
|
|
nameToDisp[opDesc.Name] = dispIndex;
|
|
MethodInfo methodInfo = null;
|
|
methodInfo = new MethodInfo(opDesc);
|
|
dispToOperationDescription[dispIndex++] = methodInfo;
|
|
paramDictionary = new Dictionary<string, ParamInfo>();
|
|
bool inVars = true;
|
|
inVars = true;
|
|
int paramCount = 0;
|
|
|
|
foreach (MessageDescription msgDesc in opDesc.Messages)
|
|
{
|
|
paramCount = 0;
|
|
|
|
|
|
if (msgDesc.Body.ReturnValue != null)
|
|
{
|
|
if (string.IsNullOrEmpty(msgDesc.Body.ReturnValue.BaseType))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.CannotResolveTypeForParamInMessageDescription, "ReturnValue", msgDesc.Body.WrapperName, msgDesc.Body.WrapperNamespace), HR.DISP_E_MEMBERNOTFOUND));
|
|
|
|
msgDesc.Body.ReturnValue.Type = Type.GetType(msgDesc.Body.ReturnValue.BaseType);
|
|
}
|
|
foreach (MessagePartDescription param in msgDesc.Body.Parts)
|
|
{
|
|
|
|
UInt32 dispID = 0;
|
|
ParamInfo paramInfo = null;
|
|
paramInfo = null;
|
|
if (!nameToDisp.TryGetValue(param.Name, out dispID))
|
|
{
|
|
|
|
dispToName[dispIndex] = param.Name;
|
|
nameToDisp[param.Name] = dispIndex;
|
|
dispID = dispIndex;
|
|
dispIndex++;
|
|
}
|
|
if (!paramDictionary.TryGetValue(param.Name, out paramInfo))
|
|
{
|
|
|
|
paramInfo = new ParamInfo();
|
|
methodInfo.paramList.Add(paramInfo);
|
|
methodInfo.dispIdToParamInfo[dispID] = paramInfo;
|
|
if (string.IsNullOrEmpty(param.BaseType))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.CannotResolveTypeForParamInMessageDescription, param.Name, msgDesc.Body.WrapperName, msgDesc.Body.WrapperNamespace), HR.DISP_E_MEMBERNOTFOUND));
|
|
paramInfo.type = Type.GetType(param.BaseType, true);
|
|
paramInfo.name = param.Name;
|
|
paramDictionary[param.Name] = paramInfo;
|
|
param.Index = paramCount;
|
|
|
|
|
|
}
|
|
param.Type = paramInfo.type;
|
|
if (inVars)
|
|
{
|
|
paramInfo.inIndex = paramCount;
|
|
}
|
|
else
|
|
{
|
|
paramInfo.outIndex = paramCount;
|
|
|
|
}
|
|
|
|
paramCount++;
|
|
|
|
|
|
}
|
|
|
|
inVars = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void IPseudoDispatch.GetIDsOfNames(UInt32 cNames, // size_is param for rgszNames
|
|
[MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 0)] string[] rgszNames,
|
|
IntPtr pDispID)
|
|
{
|
|
for (int index = 0; index < cNames; index++)
|
|
{
|
|
|
|
UInt32 dispID;
|
|
if (!nameToDisp.TryGetValue(rgszNames[index], out dispID))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.OperationNotFound, rgszNames[index]), HR.DISP_E_UNKNOWNNAME));
|
|
|
|
Marshal.WriteInt32(pDispID, index * sizeof(int), (int)dispID);
|
|
}
|
|
}
|
|
|
|
int IPseudoDispatch.Invoke(
|
|
UInt32 dispIdMember,
|
|
UInt32 cArgs,
|
|
UInt32 cNamedArgs,
|
|
IntPtr rgvarg,
|
|
[MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] UInt32[] rgdispidNamedArgs,
|
|
IntPtr pVarResult,
|
|
IntPtr pExcepInfo,
|
|
out UInt32 pArgErr
|
|
)
|
|
{
|
|
pArgErr = 0;
|
|
try
|
|
{
|
|
if (cNamedArgs > 0)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.NamedArgsNotSupported), HR.DISP_E_BADPARAMCOUNT));
|
|
MethodInfo mInfo = null;
|
|
if (!dispToOperationDescription.TryGetValue(dispIdMember, out mInfo))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.BadDispID, dispIdMember), HR.DISP_E_MEMBERNOTFOUND));
|
|
object[] ins = null;
|
|
object[] outs = null;
|
|
string action = null;
|
|
|
|
if (mInfo.paramList.Count != cArgs)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.BadDispID, dispIdMember), HR.DISP_E_BADPARAMCOUNT));
|
|
ins = new object[mInfo.opDesc.Messages[0].Body.Parts.Count];
|
|
outs = new object[mInfo.opDesc.Messages[1].Body.Parts.Count];
|
|
if (cArgs > 0)
|
|
{
|
|
if (mInfo.opDesc.Messages[0].Body.Parts.Count > 0)
|
|
{
|
|
for (int index = 0; index < mInfo.opDesc.Messages[0].Body.Parts.Count; index++)
|
|
ins[index] = null;
|
|
}
|
|
if (!mInfo.opDesc.IsOneWay && (mInfo.opDesc.Messages[1].Body.Parts.Count > 0))
|
|
{
|
|
for (int index = 0; index < mInfo.opDesc.Messages[1].Body.Parts.Count; index++)
|
|
outs[index] = null;
|
|
|
|
}
|
|
}
|
|
action = mInfo.opDesc.Messages[0].Action;
|
|
|
|
// First we take care of positional arguments
|
|
int inCount = 0;
|
|
for (int index = 0; index < cArgs; index++)
|
|
{
|
|
if (mInfo.paramList[index].inIndex != -1)
|
|
{
|
|
try
|
|
{
|
|
|
|
object val = null;
|
|
if (!mInfo.paramList[index].type.IsArray)
|
|
val = FetchVariant(rgvarg, (int)(cArgs - index - 1), mInfo.paramList[index].type);
|
|
else
|
|
val = FetchVariants(rgvarg, (int)(cArgs - index - 1), mInfo.paramList[index].type);
|
|
ins[mInfo.paramList[index].inIndex] = val;
|
|
inCount++;
|
|
}
|
|
catch (ArgumentNullException)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(SR.GetString(SR.VariantArrayNull, cArgs - index - 1));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (inCount != ins.Length)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.BadParamCount), HR.DISP_E_BADPARAMCOUNT));
|
|
|
|
|
|
object result = null;
|
|
try
|
|
{
|
|
result = SendMessage(mInfo.opDesc, action, ins, outs);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
if (pExcepInfo != IntPtr.Zero)
|
|
{
|
|
System.Runtime.InteropServices.ComTypes.EXCEPINFO exceptionInfo = new System.Runtime.InteropServices.ComTypes.EXCEPINFO();
|
|
e = e.GetBaseException();
|
|
exceptionInfo.bstrDescription = e.Message;
|
|
exceptionInfo.bstrSource = e.Source;
|
|
exceptionInfo.scode = Marshal.GetHRForException(e);
|
|
Marshal.StructureToPtr(exceptionInfo, pExcepInfo, false);
|
|
}
|
|
return HR.DISP_E_EXCEPTION;
|
|
}
|
|
|
|
|
|
|
|
if (!mInfo.opDesc.IsOneWay)
|
|
{
|
|
if (outs != null)
|
|
{
|
|
bool[] filled = new bool[outs.Length];
|
|
for (UInt32 index = 0; index < filled.Length; index++)
|
|
filled[index] = false;
|
|
for (int index = 0; index < cArgs; index++)
|
|
{
|
|
if (mInfo.paramList[index].outIndex != -1)
|
|
{
|
|
try
|
|
{
|
|
if (IsByRef(rgvarg, (int)(cArgs - index - 1)))
|
|
{
|
|
PopulateByRef(rgvarg, (int)(cArgs - index - 1), outs[mInfo.paramList[index].outIndex]);
|
|
}
|
|
}
|
|
catch (ArgumentNullException)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(SR.GetString(SR.VariantArrayNull, cArgs - index - 1));
|
|
}
|
|
|
|
filled[mInfo.paramList[index].outIndex] = true;
|
|
}
|
|
}
|
|
}
|
|
if ((result != null) && (pVarResult != IntPtr.Zero))
|
|
{
|
|
if (!result.GetType().IsArray)
|
|
Marshal.GetNativeVariantForObject(result, pVarResult);
|
|
else
|
|
{
|
|
Array arr = result as Array;
|
|
Array arrDest = Array.CreateInstance(typeof(object), arr.Length);
|
|
arr.CopyTo(arrDest, 0);
|
|
Marshal.GetNativeVariantForObject(arrDest, pVarResult);
|
|
}
|
|
}
|
|
}
|
|
return HR.S_OK;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
e = e.GetBaseException();
|
|
return Marshal.GetHRForException(e);
|
|
}
|
|
|
|
}
|
|
|
|
object SendMessage(OperationDescription opDesc, string action, object[] ins, object[] outs)
|
|
{
|
|
ProxyOperationRuntime operationRuntime = channelBuilderSettings.ServiceChannel.ClientRuntime.GetRuntime().GetOperationByName(opDesc.Name);
|
|
if (operationRuntime == null)
|
|
{
|
|
throw Fx.AssertAndThrow("Operation runtime should not be null");
|
|
}
|
|
return channelBuilderSettings.ServiceChannel.Call(action, opDesc.IsOneWay, operationRuntime, ins, outs);
|
|
}
|
|
|
|
object FetchVariant(IntPtr baseArray, int index, Type type)
|
|
{
|
|
if (baseArray == IntPtr.Zero)
|
|
{
|
|
Fx.Assert("baseArray should not be null");
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("baseArrray");
|
|
}
|
|
uint displacement = (uint)(index * Marshal.SizeOf(typeof(TagVariant)));
|
|
|
|
object ret = Marshal.GetObjectForNativeVariant(GetDisp(baseArray, displacement));
|
|
|
|
// this is neccessary because unfortunately the CLR is not very forthcomming when it comes
|
|
// to dynamically converting integer types to other integer types due to boxing
|
|
// the same goes for the array case
|
|
if (type == typeof(Int32))
|
|
{
|
|
if (ret.GetType() == typeof(Int16))
|
|
ret = (Int32)((Int16)ret);
|
|
else if (ret.GetType() != typeof(Int32))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.UnsupportedConversion, ret.GetType(), type.GetElementType()), HR.DISP_E_TYPEMISMATCH));
|
|
}
|
|
else if (type == typeof(Int64))
|
|
{
|
|
if (ret.GetType() == typeof(Int16))
|
|
ret = (Int64)((Int16)ret);
|
|
else if (ret.GetType() == typeof(Int32))
|
|
ret = (Int64)((Int32)ret);
|
|
else if (ret.GetType() != typeof(Int64))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.UnsupportedConversion, ret.GetType(), type), HR.DISP_E_TYPEMISMATCH));
|
|
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
object FetchVariants(IntPtr baseArray, int index, Type type)
|
|
{
|
|
if (baseArray == IntPtr.Zero)
|
|
{
|
|
Fx.Assert("baseArray should not be null");
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("baseArrray");
|
|
}
|
|
uint displacement = (uint)(index * Marshal.SizeOf(typeof(TagVariant)));
|
|
|
|
TagVariant varBase = (TagVariant)Marshal.PtrToStructure(GetDisp(baseArray, displacement), typeof(TagVariant));
|
|
if ((varBase.vt & (ushort)(VarEnum.VT_VARIANT | VarEnum.VT_BYREF)) == 0)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.OnlyVariantAllowedByRef), HR.DISP_E_TYPEMISMATCH));
|
|
TagVariant varActualVariant = (TagVariant)Marshal.PtrToStructure(varBase.ptr, typeof(TagVariant));
|
|
|
|
if ((varActualVariant.vt & (ushort)(VarEnum.VT_VARIANT | VarEnum.VT_BYREF | VarEnum.VT_ARRAY)) == 0)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.OnlyByRefVariantSafeArraysAllowed), HR.DISP_E_TYPEMISMATCH));
|
|
|
|
IntPtr ppArray = varActualVariant.ptr;
|
|
IntPtr pSafeArray = (IntPtr)Marshal.PtrToStructure(ppArray, typeof(IntPtr));
|
|
|
|
int dimensionsOfSafeArray = SafeNativeMethods.SafeArrayGetDim(pSafeArray);
|
|
if (dimensionsOfSafeArray != 1)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.OnlyOneDimensionalSafeArraysAllowed), HR.DISP_E_TYPEMISMATCH));
|
|
|
|
int sizeofElement = SafeNativeMethods.SafeArrayGetElemsize(pSafeArray);
|
|
if (sizeofElement != Marshal.SizeOf(typeof(TagVariant)))
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.OnlyVariantTypeElementsAllowed), HR.DISP_E_TYPEMISMATCH));
|
|
|
|
int lBound = SafeNativeMethods.SafeArrayGetLBound(pSafeArray, 1);
|
|
if (lBound > 0)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.OnlyZeroLBoundAllowed), HR.DISP_E_TYPEMISMATCH));
|
|
|
|
int uBound = SafeNativeMethods.SafeArrayGetUBound(pSafeArray, 1);
|
|
|
|
IntPtr pRawData = SafeNativeMethods.SafeArrayAccessData(pSafeArray);
|
|
try
|
|
{
|
|
object[] objects = Marshal.GetObjectsForNativeVariants(pRawData, uBound + 1);
|
|
|
|
Array arr = Array.CreateInstance(type.GetElementType(), objects.Length);
|
|
|
|
if (objects.Length == 0)
|
|
return arr;
|
|
|
|
if (type.GetElementType() != typeof(Int32) && type.GetElementType() != typeof(Int64))
|
|
{
|
|
try
|
|
{
|
|
objects.CopyTo(arr, 0);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
if (Fx.IsFatal(e))
|
|
throw;
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.UnsupportedConversion, objects[0].GetType(), type.GetElementType()), HR.DISP_E_TYPEMISMATCH));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (type.GetElementType() == typeof(Int32))
|
|
{
|
|
for (int i = 0; i < objects.Length; i++)
|
|
{
|
|
if (objects[i].GetType() == typeof(Int16))
|
|
arr.SetValue((Int32)((Int16)objects[i]), i);
|
|
else if (objects[i].GetType() == typeof(Int32))
|
|
arr.SetValue(objects[i], i);
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.UnsupportedConversion, objects[i].GetType(), type.GetElementType()), HR.DISP_E_TYPEMISMATCH));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < objects.Length; i++)
|
|
{
|
|
if (objects[i].GetType() == typeof(Int16))
|
|
arr.SetValue((Int64)((Int16)objects[i]), i);
|
|
else if (objects[i].GetType() == typeof(Int32))
|
|
arr.SetValue((Int64)((Int32)objects[i]), i);
|
|
else if (objects[i].GetType() == typeof(Int64))
|
|
arr.SetValue(objects[i], i);
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.UnsupportedConversion, objects[i].GetType(), type.GetElementType()), HR.DISP_E_TYPEMISMATCH));
|
|
}
|
|
}
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
finally
|
|
{
|
|
SafeNativeMethods.SafeArrayUnaccessData(pSafeArray);
|
|
}
|
|
}
|
|
|
|
|
|
IntPtr GetDisp(IntPtr baseAddress, uint disp)
|
|
{
|
|
long address = (long)baseAddress;
|
|
address += disp;
|
|
return (IntPtr)address;
|
|
}
|
|
|
|
void PopulateByRef(IntPtr baseArray, int index, object val)
|
|
{
|
|
if (val != null)
|
|
{
|
|
if (baseArray == IntPtr.Zero)
|
|
{
|
|
Fx.Assert("baseArray should not be null");
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("baseArrray");
|
|
}
|
|
uint displacement = (uint)(index * Marshal.SizeOf(typeof(TagVariant)));
|
|
TagVariant var = (TagVariant)Marshal.PtrToStructure(GetDisp(baseArray, displacement), typeof(TagVariant));
|
|
if ((var.vt & (ushort)VarEnum.VT_VARIANT) == 0)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new COMException(SR.GetString(SR.OnlyVariantAllowedByRef), HR.DISP_E_TYPEMISMATCH));
|
|
if (!val.GetType().IsArray)
|
|
Marshal.GetNativeVariantForObject(val, var.ptr);
|
|
else
|
|
{
|
|
Array arr = val as Array;
|
|
Array arrDest = Array.CreateInstance(typeof(object), arr.Length);
|
|
arr.CopyTo(arrDest, 0);
|
|
Marshal.GetNativeVariantForObject(arrDest, var.ptr);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bool IsByRef(IntPtr baseArray, int index)
|
|
{
|
|
|
|
|
|
if (baseArray == IntPtr.Zero)
|
|
{
|
|
Fx.Assert("baseArray should not be null");
|
|
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("baseArrray");
|
|
}
|
|
uint displacement = (uint)(index * Marshal.SizeOf(typeof(TagVariant)));
|
|
ushort vt = (ushort)Marshal.ReadInt16(GetDisp(baseArray, displacement));
|
|
if (0 != (vt & (ushort)(VarEnum.VT_BYREF)))
|
|
return true;
|
|
else
|
|
return false;
|
|
|
|
}
|
|
|
|
void IDisposable.Dispose()
|
|
{
|
|
|
|
dispToName.Clear();
|
|
nameToDisp.Clear();
|
|
dispToOperationDescription.Clear();
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|