/// <summary>
/// Invoke <paramref name="disposeAction"/> on the dispose of the object.
///
/// If parent object is disposed or being disposed, the <paramref name="disposeAction"/> is executed immediately.
/// </summary>
/// <param name="disposeAction"></param>
/// <param name="state"></param>
/// <returns>true if was added to list, false if was disposed right away</returns>
bool IDisposeList.AddDisposeAction(Action <object> disposeAction, object state)
{
// Argument error
if (disposeAction == null)
{
throw new ArgumentNullException(nameof(disposeAction));
}
// Parent is disposed/ing
if (IsDisposing)
{
disposeAction(this); return(false);
}
// Adapt to IDisposable
IDisposable disposable = new DisposeAction <object>(disposeAction, state);
// Add to list
lock (m_disposelist_lock) disposeList.Add(disposable);
// Check parent again
if (IsDisposing)
{
lock (m_disposelist_lock) disposeList.Remove(disposable); disposable.Dispose(); return(false);
}
// OK
return(true);
}
public virtual IDisposable BeginCall(string methodName)
{
// hessian version
Stream.WriteByte(Marker.Hessian);
Stream.WriteByte(0x02);
Stream.WriteByte(0x00);
// RPC call packet
Stream.WriteByte(Marker.RPCCall);
WriteString(methodName);
var scope = new object();
var disposer = new DisposeAction <object>(scope, context =>
{
var top = arrays.Pop();
if (top.Context != context)
{
throw new HessianSerializerException();
}
//Stream.WriteByte(Marker.EndList);
});
arrays.Push(disposer);
return(disposer);
}
/// <summary>
///
/// </summary>
/// <param name="elementType"></param>
/// <param name="length"></param>
public virtual IDisposable BeginFixedArray(string elementType, int length)
{
if (8 > length)
{
Stream.WriteByte((byte)(0x70 + length));
WriteString(elementType);
}
else
{
Stream.WriteByte(Marker.FixedLengthList);
WriteString(elementType);
WriteInt32(length);
}
var scope = new object();
var disposer = new DisposeAction <object>(scope, context =>
{
var top = arrays.Pop();
if (top.Context != context)
{
throw new HessianSerializerException();
}
});
arrays.Push(disposer);
return(disposer);
}
protected override sealed void SetUp()
{
base.SetUp();
_actionCalled = false;
_disposeAction = new DisposeAction(() => _actionCalled = true);
}
public async Task <int> ExecuteAsync(
CancellationToken cancellationToken = default(CancellationToken))
{
TRepositoryFactory repoFactory = default(TRepositoryFactory);
try
{
repoFactory = CreateRepositoryFactoryCallback(Configuration);
BlockchainProcessor processor = CreateBlockChainProcessor(repoFactory);
if (TargetConfiguration.ToBlock != null)
{
await processor.ExecuteAsync(TargetConfiguration.ToBlock.Value, cancellationToken, TargetConfiguration.FromBlock);
}
else
{
await processor.ExecuteAsync(cancellationToken, TargetConfiguration.FromBlock);
}
return(0);
}
catch (Exception ex)
{
log?.Error(ex);
if (repoFactory != null)
{
DisposeAction?.Invoke(repoFactory);
}
return(1);
}
}
protected override void Cleanup()
{
base.Cleanup();
_disposeAction = null;
_actionCalled = false;
}
/// <summary>
/// Invoke <paramref name="disposeAction"/> on the dispose of the object.
///
/// If parent object is disposed or being disposed, the disposable will be disposed immedialy.
/// </summary>
/// <param name="disposeAction"></param>
/// <returns>filesystem</returns>
public FileSystemProvider AddDisposeAction(Action <FileSystemProvider> disposeAction)
{
// Argument error
if (disposeAction == null)
{
throw new ArgumentNullException(nameof(disposeAction));
}
// Parent is disposed/ing
if (IsDisposing)
{
disposeAction(this); return(this);
}
// Adapt to IDisposable
IDisposable disposable = new DisposeAction <FileSystemProvider>(disposeAction, this);
// Add to list
lock (m_disposelist_lock) disposeList.Add(disposable);
// Check parent again
if (IsDisposing)
{
lock (m_disposelist_lock) disposeList.Remove(disposable); disposable.Dispose(); return(this);
}
// OK
return(this);
}
protected DispatchActiveObject(DisposeAction action, string threadName, ApartmentState apartmentState)
: base(action, threadName, apartmentState)
{
m_context = new ActiveObjectSynchronizationContext(this);
Thread.MemoryBarrier();
CallOnBackground(() => System.Threading.SynchronizationContext.SetSynchronizationContext(m_context)).WaitEmpty();
AddDisposeAction(() => System.Threading.SynchronizationContext.SetSynchronizationContext(null)).WaitEmpty();
}
protected ActiveObject(DisposeAction action, string threadName, ApartmentState apartmentState)
{
m_action = action;
m_thread = new Thread((ThreadStart) delegate { this.PumpBackgroundActions(); });
m_thread.SetApartmentState(apartmentState);
m_thread.Name = threadName;
m_thread.Start();
}
public void Dispose()
{
if (!IsSingletone && Result is IDisposable disposable)
{
disposable.Dispose();
}
DisposeAction?.Invoke();
}
public void DisposeAction_CallsAction_OnDispose()
{
var isCalled = false;
using (var sut = new DisposeAction(() => isCalled = true))
{
Assert.False(isCalled);
}
Assert.True(isCalled);
}
/// <inheritdoc />
public IDisposable Transaction(SCardReaderDisposition disposition)
{
var handle = CardHandle.Handle;
_api.BeginTransaction(handle)
.ThrowIfNotSuccess();
return(DisposeAction.Create(() => _api
.EndTransaction(handle, disposition)
.ThrowIfNotSuccess()));
}
public void DisposeAction_CanDisposeTwice()
{
int isCalled = 0;
using (var sut = new DisposeAction(() => isCalled++))
{
Assert.Equal(0, isCalled);
sut.Dispose();
Assert.Equal(1, isCalled);
}
Assert.Equal(1, isCalled);
}
public ResourceReference(UIntObject resource, string creationStackTrace)
{
Assert.NotNull(resource);
_reference = new WeakReference(resource);
_handle = resource.Handle;
_disposeAction = resource.GetDisposeAction();
_isAlive = true;
_creationStackTrace = creationStackTrace;
_resourceName = resource.ToString();
}
public void RunActionOnDispose()
{
//Given
var actionCalled = false;
var disposeAction = new DisposeAction(() => { actionCalled = true; });
//When
disposeAction.Dispose();
//Then
Assert.True(actionCalled);
}
public async Task DisposeAsync_When_UsedWithAsyncAwait_Then_DisposeShouldNotReturnUntilCompleted()
{
var manualResetEvent = new ManualResetEventSlim(false);
var testee = new DisposeAction(async() =>
{
await Task.Delay(20);
manualResetEvent.Set();
});
await testee.DisposeAsync();
manualResetEvent.IsSet.Should().BeTrue();
}
public IDisposable BeginChanging()
{
if (_changing)
{
return(DisposeAction.Empty());
}
_changing = true;
return(new DisposeAction(
() =>
{
_changing = false;
RaiseChanged();
}));
}
public void NotCallDisposeActionTwice()
{
//Given
var actionCalled = false;
var disposeAction = new DisposeAction(() => { actionCalled = true; });
disposeAction.Dispose();
actionCalled = false;
//When
disposeAction.Dispose();
//Then
Assert.False(actionCalled);
}
public void Dispose_Test()
{
var id = 0;
var disposeAction = new DisposeAction(() =>
{
id = 100;
});
disposeAction.Dispose();
Assert.Equal(100, id);
var disposeAction2 = DisposeAction.Empty;
disposeAction2.Dispose();
}
public void TrackResourceUntrack()
{
// arrange
var cts = new CancellationTokenSource();
var token = cts.Token;
var loop = new EventLoop();
var disposed = false;
var disposer = new DisposeAction(() => { disposed = true; });
var untrack = loop.TrackResource(token, disposer);
// assert
Assert.That(untrack(token), Is.True, "Expected the resource to be untracked");
Assert.That(untrack(token), Is.False, "Expected the resource to be untracked already");
// dispose the loop
loop.Dispose();
Assert.That(disposed, Is.False);
// cleanup
loop.Dispose();
cts.Dispose();
}
/// <summary>
///
/// </summary>
/// <param name="elementType"></param>
public virtual IDisposable BeginArray(string elementType)
{
Stream.WriteByte(Marker.BeginList);
WriteString(elementType);
var scope = new object();
var disposer = new DisposeAction <object>(scope, context =>
{
var top = arrays.Pop();
if (top.Context != context)
{
throw new HessianSerializerException();
}
Stream.WriteByte(Marker.EndList);
});
arrays.Push(disposer);
return(disposer);
}
protected ActiveObject(DisposeAction action, string threadName)
: this(action, threadName, DefaultApartmentState)
{
}
protected ActiveObject(DisposeAction action)
: this(action, "ActiveObject", DefaultApartmentState)
{
}
public void TrackResourceUntrack()
{
// arrange
var cts = new CancellationTokenSource();
var token = cts.Token;
var loop = new EventLoop();
var disposed = false;
var disposer = new DisposeAction(() => { disposed = true; });
var untrack = loop.TrackResource(token, disposer);
// assert
Assert.That(untrack(token), Is.True, "Expected the resource to be untracked");
Assert.That(untrack(token), Is.False, "Expected the resource to be untracked already");
// dispose the loop
loop.Dispose();
Assert.That(disposed, Is.False);
// cleanup
loop.Dispose();
cts.Dispose();
}
public Disposer(DisposeAction onDisposal)
{
_onDisposal = onDisposal;
}
public void Dispose()
{
DisposeAction.Invoke();
DisposableLock.Dispose();
}
public DisposeActionTest()
{
_Action = Substitute.For <Action>();
_DisposeAction = new DisposeAction(_Action);
}
protected DispatchActiveObject(DisposeAction action)
: this(action, "DispatchActiveObject", ActiveObject.DefaultApartmentState)
{
}
public DisposableAction(DisposeAction action)
{
this.action = action;
}
internal P_State(T value, DisposeAction <T> dispose)
{
Value = value;
Dispose = dispose;
}
internal void Internal_GetArgs(out T value, out DisposeAction <T> dispose)
{
value = _value;
dispose = _dispose;
}
public UsingClass(T value, DisposeAction <T> dispose)
{
_state = new P_State(value: value, dispose: dispose);
}
public Using(T value, DisposeAction <T> dispose)
{
_value = value;
_dispose = dispose;
_isInitialized = true;
}
