// bool Insert(K key, V value)
        public static bool Insert <K, V>(global::System.Collections.Generic.IDictionary <K, V> _this,
                                         K key,
                                         V value)
        {
            bool replacing = _this.ContainsKey(key);

            _this[key] = value;
            return(replacing);
        }
 // bool HasKey(K key)
 public static bool HasKey <K, V>(
     global::System.Collections.Generic.IDictionary <K, V> _this,
     K key)
 {
     return(_this.ContainsKey(key));
 }
 public bool Contains(TKey item)
 {
     return(dictionary.ContainsKey(item));
 }
        public void CreateTwoAndDispose()
        {
            // Create two FSW instances and dispose them.  Verify
            // that the backend IFileWatcher's Dispose
            // (watcher_handle) method got called.

            // FIXME: This only works for the
            // CoreFXFileSystemWatcherProxy not the other backends.

            using (var tmp = new TempDirectory()) {
                // have to use reflection to poke at the private fields of FileSystemWatcher.
                var watcherField = typeof(FileSystemWatcher).GetField("watcher", BindingFlags.Instance | BindingFlags.NonPublic);
                Assert.IsNotNull(watcherField);
                var watcherHandleField = typeof(FileSystemWatcher).GetField("watcher_handle", BindingFlags.Instance | BindingFlags.NonPublic);
                Assert.IsNotNull(watcherHandleField);
                var proxyType = typeof(FileSystemWatcher).Assembly.GetType("System.IO.CoreFXFileSystemWatcherProxy");
                Assert.IsNotNull(proxyType);
                // the "internal_map" maps watcher handles to backend CoreFX FSW instances
                var proxyTypeInternalMapField = proxyType.GetField("internal_map", BindingFlags.Static | BindingFlags.NonPublic);
                Assert.IsNotNull(proxyTypeInternalMapField);

                var fsw1 = new FileSystemWatcher(tmp.Path, "*");
                var fsw2 = new FileSystemWatcher(tmp.Path, "*");
                // at this point watcher and watcher_handle should be set

                global::System.Collections.Generic.IDictionary <object, global::System.IO.CoreFX.FileSystemWatcher> internal_map = null;
                object handle1 = null;
                object handle2 = null;

                // using "using" to ensure that Dispose gets called even if we throw an exception
                using (var fsw11 = fsw1)
                    using (var fsw22 = fsw2) {
                        // Once at least one FSW is initialized, watcher should be set.  But if the
                        // wrong backend is getting used, ignore this test because the other checks
                        // (internal_map in particular) won't be valid.
                        var watcher = watcherField.GetValue(fsw1);
                        Assert.IsNotNull(watcher);
                        if (!proxyType.IsAssignableFrom(watcher.GetType()))
                        {
                            Assert.Ignore("Testing only CoreFXFileSystemWatcherProxy FSW backend");
                        }

                        handle1 = watcherHandleField.GetValue(fsw1);
                        handle2 = watcherHandleField.GetValue(fsw2);

                        Assert.IsNotNull(handle1);
                        Assert.IsNotNull(handle2);

                        // Can't check for internal_map earlier - it is lazily created when the first
                        // FSW instance is created
                        internal_map = proxyTypeInternalMapField.GetValue(null)
                                       as global::System.Collections.Generic.IDictionary <object, global::System.IO.CoreFX.FileSystemWatcher>;
                        Assert.IsNotNull(internal_map);

                        // Both of handles should be in the internal map while the file system watchers
                        // are not disposed.
                        Assert.IsTrue(internal_map.ContainsKey(handle1));
                        Assert.IsTrue(internal_map.ContainsKey(handle2));
                    }

                // Dispose was called, now watcher_handle should be null

                Assert.IsNull(watcherHandleField.GetValue(fsw1));
                Assert.IsNull(watcherHandleField.GetValue(fsw2));

                // This pair are the critical checks: after we call Dispose on fsw1 and fsw2, the
                // backend's internal map shouldn't have anything keyed on handle1 and handle2.
                // Therefore System.IO.CoreFX.FileSystemWatcher instances will be disposed of, too.
                Assert.IsFalse(internal_map.ContainsKey(handle1));
                Assert.IsFalse(internal_map.ContainsKey(handle2));
            }
        }