public static void Connect(Loop loop, IPAddress ipAddress, int port, Action<Exception, Tcp> callback)
        {
            Ensure.ArgumentNotNull(loop, "loop");
            Ensure.ArgumentNotNull(ipAddress, "ipAddress");
            Ensure.ArgumentNotNull(callback, "callback");

            ConnectRequest cpr = new ConnectRequest();
            Tcp socket = new Tcp(loop);

            cpr.Callback = (status, cpr2) => {
                if (status == 0) {
                    callback(null, socket);
                } else {
                    socket.Close();
                    callback(Ensure.Success(loop), null);
                }
            };

            int r;
            if (ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) {
                r = uv_tcp_connect(cpr.Handle, socket.handle, UV.uv_ip4_addr(ipAddress.ToString(), port), CallbackPermaRequest.StaticEnd);
            } else {
                r = uv_tcp_connect6(cpr.Handle, socket.handle, UV.uv_ip6_addr(ipAddress.ToString(), port), CallbackPermaRequest.StaticEnd);
            }
            Ensure.Success(r, loop);
        }

 public static void Chown(Loop loop, string path, int uid, int gid, Action<Exception> callback)
 {
     var fsr = new FileSystemRequest();
     fsr.Callback = (ex, fsr2) => { callback(ex); };
     int r = uv_fs_chown(loop.Handle, fsr.Handle, path, uid, gid, FileSystemRequest.StaticEnd);
     Ensure.Success(r, loop);
 }

 public TTY(Loop loop, int fd, bool readable)
     : base(loop, HandleType.UV_TTY)
 {
     FileDescriptor = fd;
     int r = uv_tty_init(loop.NativeHandle, NativeHandle, fd, (readable ? 1 : 0));
     Ensure.Success(r, Loop);
 }

		public static void Create(Loop loop, string path, int mode, Action<Exception> callback)
		{
			var fsr = new FileSystemRequest();
			fsr.Callback = callback;
			int r = uv_fs_mkdir(loop.NativeHandle, fsr.Handle, path, mode, FileSystemRequest.CallbackDelegate);
			Ensure.Success(r);
		}

 public static UVTimer Every(Loop loop, TimeSpan repeat, Action callback)
 {
     var timer = new UVTimer(loop);
     timer.Tick += callback;
     timer.Start(repeat, repeat);
     return timer;
 }

 public TTY(Loop loop, IntPtr fd, bool readable)
     : base(loop, UvHandleType.UV_TTY)
 {
     FileDescriptor = fd;
     int r = uv_tty_init(loop.Handle, handle, fd, (readable ? 1 : 0));
     Ensure.Success(r, Loop);
 }

		public void Close(Loop loop, Action<Exception> callback)
		{
			var fsr = new FileSystemRequest();
			fsr.Callback = callback;
			int r = uv_fs_close(loop.NativeHandle, fsr.Handle, FileDescriptor, FileSystemRequest.CallbackDelegate);
			Ensure.Success(r);
		}

 internal UVStream(Loop loop, IntPtr handle)
     : base(loop, handle)
 {
     read_cb_unix = read_callback_u;
     read_cb_win = read_callback_w;
     stream = (uv_stream_t *)(handle.ToInt64() + Handle.Size(HandleType.UV_HANDLE));
 }

 public static void Delete(Loop loop, string path, Action<Exception> callback)
 {
     var fsr = new FileSystemRequest();
     fsr.Callback = callback;
     int r = uv_fs_rmdir(loop.NativeHandle, fsr.Handle, path, FileSystemRequest.StaticEnd);
     Ensure.Success(r, loop);
 }

 public static void Chown(Loop loop, string path, int uid, int gid, Action<Exception> callback)
 {
     var fsr = new FileSystemRequest();
     fsr.Callback = callback;
     int r = uv_fs_chown(loop.NativeHandle, fsr.Handle, path, uid, gid, FileSystemRequest.CallbackDelegate);
     Ensure.Success(r);
 }

 public FileSystemWatcher(Loop loop, string path, FileSystemEventFlags flags)
     : base(loop, HandleType.UV_FS_EVENT)
 {
     uv_fs_event = fs_event;
     int r = uv_fs_event_init(loop.NativeHandle, NativeHandle, path, uv_fs_event, (int)flags);
     Ensure.Success(r, loop);
 }

		public static void Rename(Loop loop, string path, string newPath, Action<Exception> callback)
		{
			var fsr = new FileSystemRequest();
			fsr.Callback = callback;
			int r = uv_fs_rename(loop.NativeHandle, fsr.Handle, path, newPath, fsr.End);
			Ensure.Success(r);
		}

 public FileSystemEvent(Loop loop, string path)
     : base(loop, UvHandleType.UV_FS_EVENT)
 {
     uv_fs_event = fs_event;
     int r = uv_fs_event_init(loop.Handle, handle, path, uv_fs_event, 0);
     Ensure.Success(r, loop);
 }

		public SignalWatcher(Loop loop, Signum signum, Action callback)
			: this(loop, new Signum[] { signum }, (num) => {
				if (callback != null) {
					callback();
				}
			})
		{
		}

        public Poll(Loop loop, int fd)
            : base(loop, UvHandleType.UV_POLL)
        {
            int r = uv_poll_init(loop.Handle, handle, fd);
            Ensure.Success(r, Loop);

            poll_cb += pollcallback;
        }

 internal static void Success(int errorCode, Loop loop)
 {
     if (errorCode < 0) {
         var ex = Success(loop);
         if (ex != null) {
             throw ex;
         }
     }
 }

        internal Handle(Loop loop, IntPtr handle)
        {
            Ensure.ArgumentNotNull(loop, "loop");

            this.handle = handle;
            GCHandle = GCHandle.Alloc(this);
            Loop = loop;

            Loop.handles[handle] = this;
        }

 public static void Delete(Loop loop, string path, Action<Exception> callback)
 {
     var fsr = new FileSystemRequest();
     fsr.Callback = (ex, fsr2) => {
         if (callback != null) {
             callback(ex);
         };
     };
     int r = uv_fs_rmdir(loop.Handle, fsr.Handle, path, FileSystemRequest.StaticEnd);
     Ensure.Success(r, loop);
 }

 public Udp(Loop loop)
     : base(loop, HandleType.UV_UDP)
 {
     int r = uv_udp_init(loop.NativeHandle, NativeHandle);
     Ensure.Success(r, loop);
     // we can't supply just recv_start_callback in Receive
     // because it will create a temporary delegate which could(and will) be garbage collected at any time
     // happens in my case after 10 or 20 calls
     // so we have to reference it, so it won't garbage collect it until the object itself
     // is gone
     recv_start_cb_win = recv_start_callback_w;
     recv_start_cb_unix = recv_start_callback_u;
 }

		public static void Open(Loop loop, string path, UVFileAccess access, Action<Exception, UVFile> callback)
		{
			var fsr = new FileSystemRequest(path);
			fsr.Callback = (ex) => {
				UVFile file = null;
				if (fsr.Result != IntPtr.Zero) {
					file = new UVFile(loop, fsr.Result.ToInt32());
				}
				Ensure.Success(ex, callback, file);
			};
			int r = uv_fs_open(loop.NativeHandle, fsr.Handle, path, (int)access, 0, FileSystemRequest.CallbackDelegate);
			Ensure.Success(r);
		}