public object NewWatcher(M fsw)
        {
            var handle = new object();
            var result = new C();

            result.Changed += (object o, FileSystemEventArgs args) =>
                              Task.Run(() => ProxyDispatch(o, FileAction.Modified, args));
            result.Created += (object o, FileSystemEventArgs args) =>
                              Task.Run(() => ProxyDispatch(o, FileAction.Added, args));
            result.Deleted += (object o, FileSystemEventArgs args) =>
                              Task.Run(() => ProxyDispatch(o, FileAction.Removed, args));
            result.Renamed += (object o, RenamedEventArgs args) =>
                              Task.Run(() => ProxyDispatch(o, FileAction.RenamedNewName, args));

            result.Error += (object o, ErrorEventArgs args) =>
                            Task.Run(() => ProxyDispatchError(handle, args));

            Operation(map_op: (in_map, out_map, event_map, _) => {
                in_map.Add(handle, result);
                out_map.Add(handle, fsw);
                event_map.Add(result, handle);
            });

            return(handle);
        }
        protected void Operation(Action <IDictionary <object, C>, ConditionalWeakTable <object, M>, IDictionary <object, object>, Handle> map_op = null, Action <C, M> object_op = null, object handle = null, Action <C, M> cancel_op = null)
        {
            C    internal_fsw = null;
            M    fsw = null;
            bool live, havelock;

            if (cancel_op != null)               // highest priority and must not lock
            {
                havelock = Monitor.TryEnter(instance, INTERRUPT_MS);
                live     = (handle != null && (internal_map.TryGetValue(handle, out internal_fsw) || external_map.TryGetValue(handle, out fsw)));
                if (live && havelock)
                {
                    try { cancel_op(internal_fsw, fsw); }
                    catch (Exception) { }
                }
                ;

                if (havelock)
                {
                    Monitor.Exit(instance);
                }
                if (live && !havelock)
                {
                    try {
                        var t = Task <bool> .Run(() => { cancel_op(internal_fsw, fsw); return(true); });

                        t.Wait(INTERRUPT_MS);
                    }
                    catch (Exception) { }
                }
                ;
                return;
            }
            if (map_op != null && handle == null)
            {
                lock (instance) {
                    try { map_op(internal_map, external_map, event_map, null); }
                    catch (Exception e) { throw new InvalidOperationException(nameof(map_op), e); }
                }
                return;
            }

            if (handle == null)
            {
                return;
            }

            lock (instance) {
                live = (internal_map.TryGetValue(handle, out internal_fsw) && external_map.TryGetValue(handle, out fsw));
                if (live && map_op != null)
                {
                    try { map_op(internal_map, external_map, event_map, handle); }
                    catch (Exception e) { throw new InvalidOperationException(nameof(map_op), e); };
                }
            }
            if (!live || object_op == null)
            {
                return;
            }

            try { object_op(internal_fsw, fsw); }
            catch (Exception e) { throw new InvalidOperationException(nameof(object_op), e); };
        }