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