This has more to do with lambdas than threading. A lambda captures the reference to a variable, not the variable’s value. This means that when you try to use i in your code, its value will be whatever was stored in i last. To avoid this, you should copy the variable’s value to a local … Read more
Yes, LongRunning forces the creation of a new thread outside the pool. Here’s some pseudo-disassembled code from the latest framework version: … if (task.Options HasFlag LongRunning) then create new Thread thread thread.Start(task) … Edit: converted from ugly C# to pseudocode.
Cancellation in Managed Threads: Cancellation is cooperative and is not forced on the listener. The listener determines how to gracefully terminate in response to a cancellation request. You didn’t write any code inside your Task.Run method to access your CancellationToken and to implement cancellation – so you effectively ignored the request for cancellation and ran … Read more
See the TPL documentation. They list this sample: Parallel.Invoke(() => DoSomeWork(), () => DoSomeOtherWork()); So in your case this should just work: Parallel.Invoke( () => results.LeftFront.CalcAi(), () => results.RightFront.CalcAi(), () => results.RearSuspension.CalcAi(geom, vehDef.Geometry.LTa.TaStiffness, vehDef.Geometry.RTa.TaStiffness)); EDIT: The call returns after all actions have finished executing. Invoke() is does not guarantee that they will indeed run in … Read more
It is fairly simple to build what you’re asking using ActionBlock and SendAsync(), something like: public static ITargetBlock<T> CreateGuaranteedBroadcastBlock<T>( IEnumerable<ITargetBlock<T>> targets) { var targetsList = targets.ToList(); return new ActionBlock<T>( async item => { foreach (var target in targetsList) { await target.SendAsync(item); } }, new ExecutionDataflowBlockOptions { BoundedCapacity = 1 }); } This is the most … Read more
You can’t await a task inside a lock scope (which is syntactic sugar for Monitor.Enter and Monitor.Exit). Using a Monitor directly will fool the compiler but not the framework. async-await has no thread-affinity like a Monitor does. The code after the await will probably run in a different thread than the code before it. Which … Read more
I think TaskScheduler.UnobservedTaskException Event is what you want: Occurs when a faulted Task’s unobserved exception is about to trigger exception escalation policy, which, by default, would terminate the process. So, this event is similar to DomainUnhandledException that you mentioned in your question but occurs only for tasks. BTW note, that unobserved-exceptions policy (yeah, this is … Read more
Now that the Parallel.ForEachAsync API has become part of the standard libraries (.NET 6), it makes sense to implement a variant that returns a Task<TResult[]>, based on this API. Here is an implementation: /// <summary> /// Executes a foreach loop on an enumerable sequence, in which iterations may run /// in parallel, and returns the … Read more
The cleanest way to retrieve the output of a TransformBlock is to perform a nested loop using the methods OutputAvailableAsync and TryReceive. It is a bit verbose, so you could consider encapsulating this functionality in an extension method ToListAsync: public static async Task<List<T>> ToListAsync<T>(this IReceivableSourceBlock<T> source, CancellationToken cancellationToken = default) { ArgumentNullException.ThrowIfNull(source); List<T> list = … Read more
Assuming that you don’t want to call the Stop method on the TcpListener class, there’s no perfect solution here. If you’re alright with being notified when the operation doesn’t complete within a certain time frame, but allowing the original operation to complete, then you can create an extension method, like so: public static async Task<T> … Read more