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