private unsafe static int TryExcelImpl12(int xlFunction, out object result, params object[] parameters)
{
int xlReturn;
// Set up the memory to hold the result from the call
XlOper12 resultOper = new XlOper12();
resultOper.xlType = XlType12.XlTypeEmpty;
XlOper12 *pResultOper = &resultOper; // No need to pin for local struct
// Special kind of ObjectArrayMarshaler for the parameters (rank 1)
using (XlObjectArray12Marshaler.XlObjectArray12MarshalerImpl paramMarshaler
= new XlObjectArray12Marshaler.XlObjectArray12MarshalerImpl(1, true))
{
XlOper12 **ppOperParameters = (XlOper12 **)paramMarshaler.MarshalManagedToNative(parameters);
xlReturn = Excel12v(xlFunction, parameters.Length, ppOperParameters, pResultOper);
}
// pResultOper now holds the result of the evaluated function
// Get ObjectMarshaler for the return value
ICustomMarshaler m = XlObject12Marshaler.GetInstance("");
result = m.MarshalNativeToManaged((IntPtr)pResultOper);
// And free any memory allocated by Excel
Excel12v(xlFree, 1, &pResultOper, (XlOper12 *)IntPtr.Zero);
return(xlReturn);
}
public static ICustomMarshaler GetInstance(string cookie)
{
if (null == _marshaler)
{
_marshaler = new ParamStructArrayMarshaler();
}
return(_marshaler);
}
public static ICustomMarshaler GetInstance(string cookie)
{
if (instance == null)
{
instance = new Win32WindowMarshaler();
}
return(instance);
}
public static ICustomMarshaler GetInstance(string cookie)
{
if (_instance == null)
{
_instance = new StringCustomMarshaler();
}
return(_instance);
}
public static ICustomMarshaler GetInstance(string cookie)
{
if (instance == null)
{
instance = new IconMarshaler();
}
return instance;
}
public static ICustomMarshaler GetInstance(string cookie)
{
if (instance == null)
{
instance = new ItemIdListMarshaler();
}
return(instance);
}
public byte[] GetBuffer()
{
MakeSeflRelative(); // Makes the SD one contiguous buffer.
int size = Size;
byte[] Buffer = new byte[size];
ICustomMarshaler sdm = SecurityDescriptorMarshaler.GetInstance(null);
IntPtr pSD = sdm.MarshalManagedToNative(this);
Marshal.Copy(pSD, Buffer, 0, size);
return(Buffer);
}
internal static IntPtr XlAddInManagerInfo12(IntPtr pXloperAction12)
{
Debug.WriteLine("In XlAddIn.XlAddInManagerInfo12");
ICustomMarshaler m = XlObject12Marshaler.GetInstance("");
object action = m.MarshalNativeToManaged(pXloperAction12);
object result;
if ((action is double && (double)action == 1.0))
{
InitializeIntegration();
result = IntegrationHelpers.DnaLibraryGetName();
}
else
{
result = IntegrationMarshalHelpers.GetExcelErrorObject(IntegrationMarshalHelpers.ExcelError_ExcelErrorValue);
}
return(m.MarshalManagedToNative(result));
}
internal static IntPtr RegistrationInfo(IntPtr pParam)
{
if (!_initialized)
{
return(IntPtr.Zero);
}
// CONSIDER: This might not be the right place for this.
ICustomMarshaler m = XlObject12Marshaler.GetInstance("");
object param = m.MarshalNativeToManaged(pParam);
object regInfo = XlRegistration.GetRegistrationInfo(param);
if (regInfo == null)
{
return(IntPtr.Zero); // Converted to #NUM
}
return(m.MarshalManagedToNative(regInfo));
}
public static ICustomMarshaler GetInstance(string marshalCookie)
{
if (instance == null)
instance = new XlAsyncHandleParameter12Marshaler();
return instance;
}
public static ICustomMarshaler GetInstance(string marshalCookie)
{
if (instance == null)
instance = new XlDecimalParameterMarshaler();
return instance;
}
private object CallFunction(IntPtr Function, CallingConvention callingConvention, CharSet charSet, object[] Paramaters, Type[] ParamaterTypes, MarshalAsAttribute[] Marshalling, bool[] IsByRef, Type ReturnType, MarshalAsAttribute ReturnMarshalling)
{
if (Function == IntPtr.Zero)
{
throw new ArgumentNullException("Function");
}
if (ReturnType == null)
{
throw new ArgumentNullException("ReturnType");
}
this.ThrowIfDisposed();
this.ThrowIfNoHandle();
if (callingConvention == 0)
{
callingConvention = CallingConvention.Winapi;
}
if (charSet == 0)
{
charSet = CharSet.Ansi;
}
if (Paramaters == null)
{
Paramaters = new object[0];
}
if (ParamaterTypes == null)
{
ParamaterTypes = Type.GetTypeArray(Paramaters);
}
if (Marshalling == null)
{
Marshalling = new MarshalAsAttribute[Paramaters.Length];
}
if (IsByRef == null)
{
IsByRef = new bool[Paramaters.Length];
}
if (ReturnMarshalling == null)
{
ReturnMarshalling = DefaultMarshalling(ReturnType);
}
object[] OrigParmaters = new object[Paramaters.Length];
Type[] AfterMarshalTypes = new Type[Paramaters.Length];
ICustomMarshaler[] CustomMarshalers = new ICustomMarshaler[Paramaters.Length];
IntPtr[] PtrParamaters = new IntPtr[Paramaters.Length];
for (int i = 0; i < Paramaters.Length; i++)
{
OrigParmaters[i] = Paramaters[i];
if (Marshalling[i] == null)
{
Marshalling[i] = DefaultMarshalling(ParamaterTypes[i]);
}
this.MarshalToNative(ref Paramaters[i], Marshalling[i], ParamaterTypes[i], out CustomMarshalers[i], charSet);
if (IsByRef[i])
{
if (Paramaters[i] == null)
{
AfterMarshalTypes[i] = ParamaterTypes[i];
Paramaters[i] = IntPtr.Zero;
}
else
{
AfterMarshalTypes[i] = Paramaters[i].GetType();
Paramaters[i] = this.WriteStruct(Paramaters[i]).Value;
}
}
if (Paramaters[i] is IntPtr)
{
PtrParamaters[i] = (IntPtr)Paramaters[i];
if (this.Is64BitProcess)
{
Paramaters[i] = PtrParamaters[i].ToInt64();
}
else
{
Paramaters[i] = (int)PtrParamaters[i].ToInt64();
}
}
}
CallFunctionParam Param = new CallFunctionParam()
{
Function = Function
};
if (this.Is64BitProcess)
{
int SkipOnStack = 0;
if (Paramaters.Length >= 1 &&
Marshal.SizeOf(Paramaters[0]) <= sizeof(ulong))
{
Param.Argumentsx64.RCX = StructToStruct <ulong>(Paramaters[0]);
SkipOnStack = 1;
if (Paramaters.Length >= 2 &&
Marshal.SizeOf(Paramaters[1]) <= sizeof(ulong))
{
Param.Argumentsx64.RDX = StructToStruct <ulong>(Paramaters[1]);
SkipOnStack = 2;
if (Paramaters.Length >= 3 &&
Marshal.SizeOf(Paramaters[2]) <= sizeof(ulong))
{
Param.Argumentsx64.R8 = StructToStruct <ulong>(Paramaters[2]);
SkipOnStack = 3;
if (Paramaters.Length >= 4 &&
Marshal.SizeOf(Paramaters[3]) <= sizeof(ulong))
{
Param.Argumentsx64.R9 = StructToStruct <ulong>(Paramaters[3]);
SkipOnStack = 4;
}
}
}
}
for (int i = SkipOnStack; i < Paramaters.Length; i++)
{
Param.Argumentsx64.StackLength += Utilities.Align(Marshal.SizeOf(Paramaters[i]), StackPointerAlignment);
}
if (Param.Argumentsx64.StackLength != 0)
{
IntPtr args = Marshal.AllocHGlobal(Param.Argumentsx64.StackLength);
try
{
IntPtr _args = args;
for (int i = SkipOnStack; i < Paramaters.Length; i++)
{
Marshal.StructureToPtr(Paramaters[i], _args, false);
_args += Utilities.Align(Marshal.SizeOf(Paramaters[i]), StackPointerAlignment);
}
Param.Argumentsx64.Stack = this.WriteMemory(args, Param.Argumentsx64.StackLength);
}
finally
{
Marshal.FreeHGlobal(args);
}
}
}
else
{
int SkipOnStack = 0;
switch (callingConvention)
{
case CallingConvention.Cdecl:
case CallingConvention.StdCall:
case CallingConvention.Winapi:
for (int i = SkipOnStack; i < Paramaters.Length; i++)
{
Param.Argumentsx86.StackLength += Utilities.Align(Marshal.SizeOf(Paramaters[i]), StackPointerAlignment);
}
if (Param.Argumentsx86.StackLength != 0)
{
IntPtr args = Marshal.AllocHGlobal(Param.Argumentsx86.StackLength);
try
{
IntPtr _args = args;
for (int i = SkipOnStack; i < Paramaters.Length; i++)
{
Marshal.StructureToPtr(Paramaters[i], _args, false);
_args += Utilities.Align(Marshal.SizeOf(Paramaters[i]), StackPointerAlignment);
}
Param.Argumentsx86.Stack = this.WriteMemory(args, Param.Argumentsx86.StackLength);
}
finally
{
if (args != IntPtr.Zero)
{
Marshal.FreeHGlobal(args);
}
}
}
break;
case CallingConvention.FastCall:
if (Paramaters.Length >= 1 &&
Marshal.SizeOf(Paramaters[0]) <= sizeof(uint))
{
Param.Argumentsx86.ECX = StructToStruct <uint>(Paramaters[0]);
SkipOnStack = 1;
if (Paramaters.Length >= 2 &&
Marshal.SizeOf(Paramaters[1]) <= sizeof(uint))
{
Param.Argumentsx86.EDX = StructToStruct <uint>(Paramaters[1]);
SkipOnStack = 2;
}
}
goto case CallingConvention.StdCall;
case CallingConvention.ThisCall:
if (Paramaters.Length < 1)
{
throw new ArgumentException("Calling convention requires at least one argument.");
}
if (Marshal.SizeOf(Paramaters[0]) > sizeof(uint))
{
throw new ArgumentException("Paramater 0 must be this paramater and less than or equal to 32-bits.");
}
Param.Argumentsx86.ECX = StructToStruct <uint>(Paramaters[0]);
SkipOnStack = 1;
goto case CallingConvention.Cdecl;
default:
throw new ArgumentException(null, "callingConvention");
}
}
try
{
uint res = this.CallFunctionThreadProc(this.NativeCallFunction, ref Param);
if (res != Win32.ERROR_SUCCESS)
{
throw new Exception("CallFunction failed", new Win32Exception((int)res));
}
}
finally
{
if (Param.Argumentsx86.Stack != IntPtr.Zero)
{
this.FreeMemory(Param.Argumentsx86.Stack);
}
for (int i = 0; i < Paramaters.Length; i++)
{
if (IsByRef[i])
{
IntPtr PtrParamater = PtrParamaters[i];
try
{
if (AfterMarshalTypes[i] == typeof(IntPtr))
{
Paramaters[i] = PtrParamaters[i] = this.ReadIntPtr(PtrParamater);
}
else if (PtrParamater == IntPtr.Zero)
{
Paramaters[i] = null;
}
else
{
Paramaters[i] = this.ReadStruct(PtrParamater, AfterMarshalTypes[i]);
}
}
finally
{
if (PtrParamater != IntPtr.Zero)
{
this.FreeMemory(PtrParamater);
}
}
}
this.MarshalToManaged(ref Paramaters[i], OrigParmaters[i], PtrParamaters[i], Marshalling[i], ParamaterTypes[i], CustomMarshalers[i], charSet, IsByRef[i]);
}
}
FunctionReturn ReturnValue;
if (this.Is64BitProcess)
{
ReturnValue = Param.ReturnValuex64;
}
else
{
ReturnValue = Param.ReturnValuex86;
}
if (ReturnMarshalling != null)
{
object _ReturnValue = ReturnValue.Int64;
this.MarshalToManaged(ref _ReturnValue, null, ReturnValue.IntPtr, ReturnMarshalling, ReturnType, null, charSet, true);
return(_ReturnValue);
}
else if (ReturnType == typeof(FunctionReturn))
{
return(ReturnValue);
}
else if (ReturnType == typeof(sbyte))
{
return(ReturnValue.Int8);
}
else if (ReturnType == typeof(byte))
{
return(ReturnValue.UInt8);
}
else if (ReturnType == typeof(short))
{
return(ReturnValue.Int16);
}
else if (ReturnType == typeof(ushort))
{
return(ReturnValue.UInt16);
}
else if (ReturnType == typeof(int))
{
return(ReturnValue.Int32);
}
else if (ReturnType == typeof(uint))
{
return(ReturnValue.UInt32);
}
else if (ReturnType == typeof(long))
{
return(ReturnValue.Int64);
}
else if (ReturnType == typeof(ulong))
{
return(ReturnValue.UInt64);
}
else if (ReturnType == typeof(IntPtr))
{
return(ReturnValue.IntPtr);
}
else if (ReturnType == typeof(UIntPtr))
{
return(ReturnValue.UIntPtr);
}
else
{
throw new NotSupportedException(string.Format("Return type `{0}` is not supported", ReturnType));
}
}
public static ICustomMarshaler GetInstance(string marshalCookie)
{
if (instance == null)
instance = new XlDateTimeMarshaler();
return instance;
}
public static ICustomMarshaler GetInstance(string marshalCookie)
{
if (instance == null)
instance = new XlBooleanReturnMarshaler();
return instance;
}
private void MarshalToManaged(ref object Paramater, object OrigParmater, IntPtr PtrParamater, MarshalAsAttribute Marshalling, Type ParamaterType, ICustomMarshaler CustomMarshaler, CharSet charSet, bool IsByRef)
{
if (Marshalling == null)
{
return;
}
switch (Marshalling.Value)
{
case UnmanagedType.AnsiBStr:
try
{
if (ParamaterType == typeof(StringBuilder))
{
StringBuilder StrParam = (StringBuilder)OrigParmater;
if (IsByRef && StrParam == null)
{
Paramater = StrParam = new StringBuilder();
}
if (StrParam == null)
{
break;
}
if (PtrParamater == IntPtr.Zero)
{
StrParam.Clear();
}
else
{
this.ReadPrefixedStringAnsi(PtrParamater, StrParam);
}
}
else if (IsByRef && ParamaterType == typeof(string))
{
if (PtrParamater == IntPtr.Zero)
{
Paramater = null;
}
else
{
Paramater = this.ReadPrefixedStringAnsi(PtrParamater);
}
}
}
finally
{
if (PtrParamater != IntPtr.Zero)
{
this.FreeMemory(PtrParamater);
}
}
break;
case UnmanagedType.Bool:
if (IsByRef)
{
Paramater = Convert.ToUInt32(Paramater) != 0U;
}
break;
case UnmanagedType.BStr:
try
{
if (ParamaterType == typeof(StringBuilder))
{
StringBuilder StrParam = (StringBuilder)OrigParmater;
if (IsByRef && StrParam == null)
{
Paramater = StrParam = new StringBuilder();
}
if (StrParam == null)
{
break;
}
if (PtrParamater == IntPtr.Zero)
{
StrParam.Clear();
}
else
{
this.ReadPrefixedStringUni(PtrParamater, StrParam);
}
}
else if (IsByRef && ParamaterType == typeof(string))
{
if (PtrParamater == IntPtr.Zero)
{
Paramater = null;
}
else
{
Paramater = this.ReadPrefixedStringUni(PtrParamater);
}
}
}
finally
{
if (PtrParamater != IntPtr.Zero)
{
this.FreeMemory(PtrParamater);
}
}
break;
case UnmanagedType.CustomMarshaler:
if (CustomMarshaler == null)
{
CustomMarshaler = this.CreateCustomMarshaller(Marshalling);
}
try
{
if (IsByRef)
{
Paramater = CustomMarshaler.MarshalNativeToManaged(PtrParamater);
}
}
finally
{
CustomMarshaler.CleanUpNativeData(PtrParamater);
}
break;
case UnmanagedType.I1:
case UnmanagedType.I2:
case UnmanagedType.I4:
case UnmanagedType.I8:
case UnmanagedType.SysInt:
case UnmanagedType.SysUInt:
case UnmanagedType.U1:
case UnmanagedType.U2:
case UnmanagedType.U4:
case UnmanagedType.U8:
if (IsByRef)
{
Paramater = StructToStruct(Paramater, ParamaterType);
}
break;
case UnmanagedType.LPArray:
try
{
if (PtrParamater == IntPtr.Zero)
{
Paramater = null;
}
else
{
Type ArrElementType = ParamaterType.GetElementType();
Array ArrParam;
int ArrLength = 0;
if (IsByRef)
{
ArrLength = Marshalling.SizeConst;
Paramater = ArrParam = Array.CreateInstance(ArrElementType, ArrLength);
}
else
{
ArrParam = (Array)OrigParmater;
if (ArrParam != null)
{
ArrLength = ArrParam.Length;
}
}
if (ArrLength > 0)
{
int bSize = ArrLength * Marshal.SizeOf(ArrElementType);
Buffer.BlockCopy(this.ReadBytes(PtrParamater, bSize), 0, ArrParam, 0, bSize);
}
}
}
finally
{
if (PtrParamater != IntPtr.Zero)
{
this.FreeMemory(PtrParamater);
}
}
break;
case UnmanagedType.LPStruct:
try
{
if (IsByRef && PtrParamater != IntPtr.Zero)
{
Paramater = this.ReadStruct(PtrParamater, ParamaterType);
}
}
finally
{
if (PtrParamater != IntPtr.Zero)
{
this.FreeMemory(PtrParamater);
}
}
break;
case UnmanagedType.LPStr:
try
{
if (ParamaterType == typeof(StringBuilder))
{
StringBuilder StrParam = (StringBuilder)OrigParmater;
if (IsByRef && StrParam == null)
{
Paramater = StrParam = new StringBuilder();
}
if (StrParam == null)
{
break;
}
if (PtrParamater == IntPtr.Zero)
{
StrParam.Clear();
}
else
{
this.ReadStringAnsi(PtrParamater, StrParam);
}
}
else if (IsByRef && ParamaterType == typeof(string))
{
if (PtrParamater == IntPtr.Zero)
{
Paramater = null;
}
else
{
Paramater = this.ReadStringAnsi(PtrParamater);
}
}
}
finally
{
if (PtrParamater != IntPtr.Zero)
{
this.FreeMemory(PtrParamater);
}
}
break;
case UnmanagedType.LPTStr:
if (charSet == CharSet.Ansi || charSet == CharSet.None)
{
goto case UnmanagedType.LPStr;
}
else if (charSet == CharSet.Auto || charSet == CharSet.Unicode)
{
goto case UnmanagedType.LPWStr;
}
else
{
throw new NotSupportedException();
}
case UnmanagedType.LPWStr:
try
{
if (ParamaterType == typeof(StringBuilder))
{
StringBuilder StrParam = (StringBuilder)OrigParmater;
if (IsByRef && StrParam == null)
{
Paramater = StrParam = new StringBuilder();
}
if (StrParam == null)
{
break;
}
if (PtrParamater == IntPtr.Zero)
{
StrParam.Clear();
}
else
{
this.ReadStringUni(PtrParamater, StrParam);
}
}
else if (IsByRef && ParamaterType == typeof(string))
{
if (PtrParamater == IntPtr.Zero)
{
Paramater = null;
}
else
{
Paramater = this.ReadStringUni(PtrParamater);
}
}
}
finally
{
if (PtrParamater != IntPtr.Zero)
{
this.FreeMemory(PtrParamater);
}
}
break;
case UnmanagedType.TBStr:
if (charSet == CharSet.Ansi || charSet == CharSet.None)
{
goto case UnmanagedType.AnsiBStr;
}
else if (charSet == CharSet.Auto || charSet == CharSet.Unicode)
{
goto case UnmanagedType.BStr;
}
else
{
throw new NotSupportedException();
}
case UnmanagedType.VariantBool:
if (IsByRef)
{
Paramater = Convert.ToInt16(Paramater) == -1;
}
break;
}
}
private void MarshalToNative(ref object Paramater, MarshalAsAttribute Marshalling, Type ParamaterType, out ICustomMarshaler CustomMarshaler, CharSet charSet)
{
CustomMarshaler = null;
if (ParamaterType == typeof(SafeHandle) || ParamaterType.IsSubclassOf(typeof(SafeHandle)))
{
Paramater = ((SafeHandle)Paramater).Value;
}
if (Marshalling == null)
{
return;
}
switch (Marshalling.Value)
{
default:
case UnmanagedType.AsAny:
case UnmanagedType.ByValArray:
case UnmanagedType.ByValTStr:
case UnmanagedType.Currency:
case UnmanagedType.Error:
case UnmanagedType.FunctionPtr:
case UnmanagedType.IDispatch:
case UnmanagedType.Interface:
case UnmanagedType.IUnknown:
case UnmanagedType.R4:
case UnmanagedType.R8:
case UnmanagedType.SafeArray:
case UnmanagedType.Struct:
case UnmanagedType.VBByRefStr:
throw new NotSupportedException(string.Format("MarshalAs type {0} not supported", Marshalling.Value));
case UnmanagedType.AnsiBStr:
if (Paramater == null)
{
Paramater = IntPtr.Zero;
}
else if (ParamaterType == typeof(string))
{
Paramater = this.WritePrefixedStringAnsi((string)Paramater);
}
else if (ParamaterType == typeof(StringBuilder))
{
Paramater = this.WritePrefixedStringAnsi((StringBuilder)Paramater);
}
else
{
throw new NotSupportedException();
}
break;
case UnmanagedType.Bool:
Paramater = Convert.ToBoolean(Paramater) ? 1U : 0U;
break;
case UnmanagedType.BStr:
if (Paramater == null)
{
Paramater = IntPtr.Zero;
}
else if (ParamaterType == typeof(string))
{
Paramater = this.WritePrefixedStringUni((string)Paramater);
}
else if (ParamaterType == typeof(StringBuilder))
{
Paramater = this.WritePrefixedStringUni((StringBuilder)Paramater);
}
else
{
throw new NotSupportedException();
}
break;
case UnmanagedType.CustomMarshaler:
CustomMarshaler = this.CreateCustomMarshaller(Marshalling);
Paramater = CustomMarshaler.MarshalManagedToNative(Paramater);
break;
case UnmanagedType.I1:
Paramater = StructToStruct <sbyte>(Paramater);
break;
case UnmanagedType.I2:
Paramater = StructToStruct <short>(Paramater);
break;
case UnmanagedType.I4:
Paramater = StructToStruct <int>(Paramater);
break;
case UnmanagedType.I8:
Paramater = StructToStruct <long>(Paramater);
break;
case UnmanagedType.LPArray:
Array ArrParam = (Array)Paramater;
if (ArrParam == null)
{
Paramater = IntPtr.Zero;
}
else
{
Paramater = this.WriteArray(ArrParam);
}
break;
case UnmanagedType.LPStruct:
Paramater = this.WriteStruct(Paramater);
break;
case UnmanagedType.LPStr:
if (Paramater == null)
{
Paramater = IntPtr.Zero;
}
else if (ParamaterType == typeof(string))
{
Paramater = this.WriteStringAnsi((string)Paramater);
}
else if (ParamaterType == typeof(StringBuilder))
{
Paramater = this.WriteStringAnsi((StringBuilder)Paramater);
}
else
{
throw new NotSupportedException();
}
break;
case UnmanagedType.LPTStr:
if (charSet == CharSet.Ansi || charSet == CharSet.None)
{
goto case UnmanagedType.LPStr;
}
else if (charSet == CharSet.Auto || charSet == CharSet.Unicode)
{
goto case UnmanagedType.LPWStr;
}
else
{
throw new NotSupportedException();
}
case UnmanagedType.LPWStr:
if (Paramater == null)
{
Paramater = IntPtr.Zero;
}
else if (ParamaterType == typeof(string))
{
Paramater = this.WriteStringUni((string)Paramater);
}
else if (ParamaterType == typeof(StringBuilder))
{
Paramater = this.WriteStringUni((StringBuilder)Paramater);
}
else
{
throw new NotSupportedException();
}
break;
case UnmanagedType.SysInt:
if (this.Is64BitProcess)
{
Paramater = StructToStruct <long>(Paramater);
}
else
{
Paramater = StructToStruct <int>(Paramater);
}
break;
case UnmanagedType.SysUInt:
if (this.Is64BitProcess)
{
Paramater = StructToStruct <ulong>(Paramater);
}
else
{
Paramater = StructToStruct <uint>(Paramater);
}
break;
case UnmanagedType.TBStr:
if (charSet == CharSet.Ansi || charSet == CharSet.None)
{
goto case UnmanagedType.AnsiBStr;
}
else if (charSet == CharSet.Auto || charSet == CharSet.Unicode)
{
goto case UnmanagedType.BStr;
}
else
{
throw new NotSupportedException();
}
case UnmanagedType.U1:
Paramater = StructToStruct <byte>(Paramater);
break;
case UnmanagedType.U2:
Paramater = StructToStruct <ushort>(Paramater);
break;
case UnmanagedType.U4:
Paramater = StructToStruct <uint>(Paramater);
break;
case UnmanagedType.U8:
Paramater = StructToStruct <ulong>(Paramater);
break;
case UnmanagedType.VariantBool:
Paramater = (short)(Convert.ToBoolean(Paramater) ? -1 : 0);
break;
}
if (Paramater is SafeHandle)
{
Paramater = ((SafeHandle)Paramater).Value;
}
}
