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));
}
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;
}
}
