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