//
using System.Runtime.InteropServices;
+using System.Security.Permissions;
namespace System.Threading
{
+ [ComVisible (true)]
public class Overlapped
{
IAsyncResult ares;
int offsetL;
int offsetH;
int evt;
+ IntPtr evt_ptr;
public Overlapped ()
{
}
+ [Obsolete ("Not 64bit compatible. Please use the constructor that takes IntPtr for the event handle", false)]
public Overlapped(int offsetLo, int offsetHi, int hEvent, IAsyncResult ar)
{
offsetL = offsetLo;
ares = ar;
}
+ public Overlapped (int offsetLo, int offsetHi, IntPtr hEvent,
+ IAsyncResult ar)
+ {
+ offsetL = offsetLo;
+ offsetH = offsetHi;
+ evt_ptr = hEvent;
+ ares = ar;
+ }
+
[CLSCompliant(false)]
unsafe public static void Free (NativeOverlapped *nativeOverlappedPtr)
{
Overlapped result = new Overlapped ();
result.offsetL = nativeOverlappedPtr->OffsetLow;
result.offsetH = nativeOverlappedPtr->OffsetHigh;
- result.evt = nativeOverlappedPtr->EventHandle;
+ result.evt = (int)nativeOverlappedPtr->EventHandle;
return result;
}
[CLSCompliant(false)]
+ [Obsolete ("Use Pack(iocb, userData) instead", false)]
+ [MonoTODO ("Security - we need to propagate the call stack")]
unsafe public NativeOverlapped *Pack (IOCompletionCallback iocb)
{
NativeOverlapped *result = (NativeOverlapped *) Marshal.AllocHGlobal (Marshal.SizeOf (typeof (NativeOverlapped)));
result->OffsetLow = offsetL;
result->OffsetHigh = offsetH;
- result->EventHandle = evt;
+ result->EventHandle = (IntPtr)evt;
return result;
}
+
+ [CLSCompliant (false)]
+ [ComVisible (false)]
+ [MonoTODO ("handle userData")]
+ unsafe public NativeOverlapped *Pack (IOCompletionCallback iocb, object userData)
+ {
+ NativeOverlapped *result = (NativeOverlapped *) Marshal.AllocHGlobal (Marshal.SizeOf(typeof(NativeOverlapped)));
+ result->OffsetLow = offsetL;
+ result->OffsetHigh = offsetH;
+ result->EventHandle = evt_ptr;
+ return(result);
+ }
[CLSCompliant(false)]
+ [Obsolete ("Use UnsafePack(iocb, userData) instead", false)]
+ [SecurityPermission (SecurityAction.Demand, ControlEvidence=true, ControlPolicy=true)]
unsafe public NativeOverlapped *UnsafePack (IOCompletionCallback iocb)
{
+ // no need to propagate the call stack in the unsafe version
return Pack (iocb);
}
+ [ComVisible (false)]
+ [CLSCompliant (false)]
+ unsafe public NativeOverlapped *UnsafePack (IOCompletionCallback iocb, object userData)
+ {
+ return Pack (iocb, userData);
+ }
+
public IAsyncResult AsyncResult {
get { return ares; }
set { ares = value; }
}
+ [Obsolete ("Not 64bit compatible. Use EventHandleIntPtr instead.", false)]
public int EventHandle {
get { return evt; }
set { evt = value; }
}
+ [ComVisible (false)]
+ public IntPtr EventHandleIntPtr
+ {
+ get{
+ return(evt_ptr);
+ }
+ set{
+ evt_ptr = value;
+ }
+ }
+
public int OffsetHigh {
get { return offsetH; }
set { offsetH = value; }