/// <inheritdoc cref="Track(ITrackingScope, Guid, Action{ITrackingScope, CancellationToken}, CancellationToken)"/> public static void Track(this ITrackingScope scope, Action <ITrackingScope, CancellationToken> workload, CancellationToken cancellationToken = default) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } scope.CreateAutoTracker(Guid.NewGuid()).Track(workload, cancellationToken); }
/// <inheritdoc cref="Track(ITrackingScope, Guid, Action{ITrackingScope, CancellationToken}, CancellationToken)"/> public static void Track(this ITrackingScope scope, Action workload) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } scope.CreateAutoTracker(Guid.NewGuid()).Track(workload); }
/// <summary> /// Creates a new manual tracker under this scope with an automatic id. /// </summary> /// <param name="scope">The scope under which to create the new tracker.</param> /// <returns>The new tracker in a stopped state.</returns> public static IManualTracker CreateManualTracker(this ITrackingScope scope) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } return(scope.CreateManualTracker(Guid.NewGuid())); }
/// <inheritdoc cref="TrackAsync(ITrackingScope, Guid, Func{ITrackingScope, CancellationToken, Task}, CancellationToken)"/> public static Task <TResult> TrackAsync <TResult>(this ITrackingScope scope, Guid id, Func <ITrackingScope, CancellationToken, Task <TResult> > workload, CancellationToken cancellationToken = default) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } return(scope.CreateAutoTracker(id).TrackAsync(workload, cancellationToken)); }
/// <inheritdoc cref="TrackAsync(ITrackingScope, Guid, Func{ITrackingScope, CancellationToken, Task}, CancellationToken)"/> public static Task <TResult> TrackAsync <TResult>(this ITrackingScope scope, Func <Task <TResult> > workload) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } return(scope.CreateAutoTracker(Guid.NewGuid()).TrackAsync(workload)); }
/// <inheritdoc cref="IAutoTracker.Track{TResult}(Func{ITrackingScope, CancellationToken, TResult}, CancellationToken)"/> public static TResult Track <TResult>(this ITrackingScope scope, Func <ITrackingScope, CancellationToken, TResult> workload, CancellationToken cancellationToken = default) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } return(scope.CreateAutoTracker(Guid.NewGuid()).Track(workload, cancellationToken)); }
/// <inheritdoc cref="TrackAsync(ITrackingScope, Guid, Func{ITrackingScope, CancellationToken, Task}, CancellationToken)"/> public static Task TrackAsync(this ITrackingScope scope, Guid id, Func <Task> workload) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } return(scope.CreateAutoTracker(id).TrackAsync(workload)); }
/// <inheritdoc cref="IAutoTracker.Track{TResult}(Func{ITrackingScope, CancellationToken, TResult}, CancellationToken)"/> public static TResult Track <TResult>(this ITrackingScope scope, Guid id, Func <ITrackingScope, TResult> workload) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } return(scope.CreateAutoTracker(id).Track(workload)); }
public void CreateManualTrackerThrowsOnNullScope() { // arrange ITrackingScope scope = null; // act var ex = Assert.Throws <ArgumentNullException>(() => scope.CreateManualTracker()); // assert Assert.Equal(nameof(scope), ex.ParamName); }
public void VoidTrackWithScopeAndTokenThrowsOnNullScope() { // arrange ITrackingScope scope = null; Action <ITrackingScope, CancellationToken> workload = null; // act var ex = Assert.Throws <ArgumentNullException>(() => scope.Track(workload, CancellationToken.None)); // assert Assert.Equal(nameof(scope), ex.ParamName); }
public void ResultTrackWithIdAndScopeThrowsOnNullScope() { // arrange ITrackingScope scope = null; Func <ITrackingScope, int> workload = null; // act var ex = Assert.Throws <ArgumentNullException>(() => scope.Track(Guid.NewGuid(), workload)); // assert Assert.Equal(nameof(scope), ex.ParamName); }
public void VoidTrackThrowsOnNullScope() { // arrange ITrackingScope scope = null; Action workload = null; // act var ex = Assert.Throws <ArgumentNullException>(() => scope.Track(workload)); // assert Assert.Equal(nameof(scope), ex.ParamName); }
/// <inheritdoc cref="StartManualTracker(ITrackingScope, Guid)"/> public static IManualTracker StartManualTracker(this ITrackingScope scope) { if (scope is null) { throw new ArgumentNullException(nameof(scope)); } var tracker = scope.CreateManualTracker(); tracker.Start(); return(tracker); }
public void StartManualTrackerWithIdThrowsOnNullScope() { // arrange ITrackingScope scope = null; var id = Guid.NewGuid(); // act var ex = Assert.Throws <ArgumentNullException>(() => scope.StartManualTracker(id)); // assert Assert.Equal(nameof(scope), ex.ParamName); }
public void VoidTrackWithIdAndScopeThrowsOnNullScope() { // arrange ITrackingScope scope = null; var id = Guid.NewGuid(); Action <ITrackingScope> workload = null; // act var ex = Assert.Throws <ArgumentNullException>(() => scope.Track(id, workload)); // assert Assert.Equal(nameof(scope), ex.ParamName); }
public void VoidTrackWithIdAndScopeAndTokenWorks() { // arrange var id = Guid.NewGuid(); var tracker = Mock.Of <IAutoTracker>(); ITrackingScope scope = Mock.Of <ITrackingScope>(x => x.CreateAutoTracker(id) == tracker); Action <ITrackingScope, CancellationToken> workload = null; var token = CancellationToken.None; // act scope.Track(id, workload, token); // assert Mock.Get(scope).VerifyAll(); Mock.Get(tracker).Verify(x => x.Track(workload, token)); }
public IAutoTracker CreateAutoSyncTracker(Guid id, ITrackingScope scope) { var context = _provider.GetRequiredService <IChronoscopeContext>(); return(new AutoTracker(context, id, scope)); }
public void ResultTrackWithIdThrowsOnNullScope() { // arrange ITrackingScope scope = null;
public void Push(ITrackingScope scope) { _stack.Value = _stack.Value.Push(scope); }
static int workload(ITrackingScope scope) { return(123); }
public AutoTracker(IChronoscopeContext context, Guid id, ITrackingScope scope) : base(context, id, scope.Id) { _scope = scope; }
static void workload(ITrackingScope scope, CancellationToken token) { throw new InvalidOperationException("Test"); }