This is a stripped version of the Spicy Pixel Concurrency Kit, used to integrate debuggable code in unity projects. Also alternated to enable support for Unity .Net2.0 Subset compatibility level.

Put SpicyPixel.Threading.dll, SpicyPixel.Threading.Unity.dll and System.Threading.dll in Unity assets

Checkout System.Threading folder, open solution i Visual Studio and build release version. Target framework should be .NET Framework 3.5

Following modifications have been done to support Unity .Net 2.0 Subset compatibility level: - Call to ThreadPool.UnsafeQueueUserWorkItem have been replaced by ThreadPool.QueueUserWorkItem

Download it now in the Unity Asset Store

Get the Source Code on GitHub

The Concurrency Kit is a .NET/Mono kit that includes a port of the Task Parallel Library and extends it to support Fibers, Coroutines, and Unity. Fibers allow code paths to execute concurrently using a single thread by leveraging the co-operative yielding behavior of coroutines.

// Start task 1
var t1 = Task.Factory.StartNew(() => PatHead());
 
// Start task 2
var t2 = Task.Factory.StartNew(() => RubTummy());
 
// This task will complete when t1 and t2 complete and
// then it will continue by executing a happy dance.
Task.WhenAll(t1, t2).ContinueWith(t3 => HappyDance());

Because code written in this manner is designed with concurrency in mind, tasks can run in parallel across multiple threads or as concurrent fibers on a single thread by changing out the task scheduler. This flexibility makes it easy to write and maintain portable asynchronous code that scales.

Use the .NET 4+ asynchronous task model in your designs – it’s feature rich and the framework standard going forward

public class HttpClient {
  public Task<HttpResponseMessage> GetAsync(
    string requestUri);
 
  public Task<HttpResponseMessage> PostAsync(
    string requestUri,
    HttpContent content);
}

Start a background task using the thread pool and complete the operation on the main thread

Declaratively schedule workflows with chained asynchronous tasks and anonymous delegates

Task.Factory.StartNew(() => DoSomethingFromThreadPool()).
  ContinueWith(lastTask => DoSomethingFromMainThread(), 
  mainThreadScheduler);

Coordinate between concurrently executing tasks

Task.Factory.ContinueWhenAny(tasksToRun, 
  winner => print("The winner is: " + winner));

Easily cancel tasks in progress

CancellationTokenSource tokenSource = new CancellationTokenSource();
void Start()
{
  Task.Factory.StartNew(() => DoSomething(), tokenSource.Token);
}
void OnClick()
{
  tokenSource.Cancel();
}

• Leverage multiple CPU cores for maximum throughput
• Maximize individual thread usage with co-operative multitasking and task inlining
• Control how tasks are scheduled and the level of concurrency

• Write more maintainable, more performant asynchronous code

See the API Reference for what is included or learn more about the Concurrency Kit.

Copyright (c) 2012-2014 Spicy Pixel, Inc.