public void Dispose_TwiceWithOnlyDisposeOnceSet_DisposeActionIsCalledOnce() { var actionCalledCounter = 0; var d = new DelegateDisposable(() => actionCalledCounter++, true); d.Dispose(); d.Dispose(); Assert.Equal(1, actionCalledCounter); }
public void Dispose_Twice_DisposeActionIsCalledTwice() { var actionCalledCounter = 0; var d = new DelegateDisposable(() => actionCalledCounter++, false); d.Dispose(); d.Dispose(); Assert.Equal(2, actionCalledCounter); }
public void Disposing() { int i = 0; var d = new DelegateDisposable(); d.DisposingAction = () => { i++; }; d.Dispose(); i.Is(1); d.Dispose(); i.Is(1); }
public void ExplicitFinalizerTest() { /* * I referred to the following. * https://www.inversionofcontrol.co.uk/unit-testing-finalizers-in-csharp/ */ int managed = 0; int unmanaged = 0; WeakReference <DelegateDisposable> weak = null; Action exec = () => { var d = new DelegateDisposable(() => { managed += 1; }, () => { unmanaged += 1; }); d.Dispose(); weak = new WeakReference <DelegateDisposable>(d, true); }; exec(); GC.Collect(0, GCCollectionMode.Forced); GC.WaitForPendingFinalizers(); GC.Collect(0, GCCollectionMode.Forced); managed.Is(1); unmanaged.Is(1); }
public void Dispose_Once_DisposeActionIsCalled() { var actionCalled = false; var d = new DelegateDisposable(() => actionCalled = true, true); d.Dispose(); Assert.True(actionCalled); }
public void DelegateDisposable_Create() { int count = 0; var disposable = new DelegateDisposable(() => count = 1); Assert.NotNull(disposable); Assert.IsAssignableFrom <IDisposable>(disposable); disposable.Dispose(); Assert.Equal(1, count); }
/// <summary> /// Register event handler using weak reference event pattern. /// </summary> /// <typeparam name="TEventSupplier">A type of the object that exposes an event.</typeparam> /// <typeparam name="TDelegate">A type of the delegate that actual receive event.</typeparam> /// <param name="supplier">The object that exposes an event.</param> /// <param name="converter">A delegate that relays the event to an event handler that can not be registered directly.</param> /// <param name="addHandler">An Action to add event handler.</param> /// <param name="removeHandler">An Action to remove event handler.</param> /// <param name="handler">An event handler.</param> /// <returns>An instance of IDIsposable to unsubscribe.</returns> public static IDisposable WeakSubscribe <TEventSupplier, TEventArgs, TDelegate>( this TEventSupplier supplier, Func <TDelegate, EventHandler <TEventArgs> > converter, Action <TEventSupplier, EventHandler <TEventArgs> > addHandler, Action <TEventSupplier, EventHandler <TEventArgs> > removeHandler, TDelegate handler) { if (supplier == null) { throw new ArgumentNullException(nameof(supplier)); } if (converter == null) { throw new ArgumentNullException(nameof(converter)); } if (addHandler == null) { throw new ArgumentNullException(nameof(addHandler)); } if (removeHandler == null) { throw new ArgumentNullException(nameof(removeHandler)); } if (handler == null) { throw new ArgumentNullException(nameof(handler)); } var inner = new DelegateDisposable(); var outer = new DelegateDisposable(); var wref = new WeakReference <IDisposable>(outer); void relayHandler(object s, TEventArgs e) { if (wref.TryGetTarget(out IDisposable d)) { converter(handler)(s, e); } else { inner.Dispose(); } } addHandler(supplier, relayHandler); inner.DisposingAction = () => removeHandler(supplier, relayHandler); outer.DisposingAction = inner.Dispose; return(outer); }
public async void DisposingMulti() { int i = 0; var d = new DelegateDisposable(() => { i++; }); List <Task> tasks = new List <Task>(); for (int j = 0; j < 10; j++) { tasks.Add(Task.Run(() => d.Dispose())); } await Task.WhenAll(tasks); i.Is(1); }