Ich habe ein wenig mit dem C#6-Support von alexzzzz getestet und gespielt, und bin zum Ergebnis gekommen, dass da noch ein wenig Potenzial zur Verbesserung ist. In Worten: Eine Erweiterung des MonoBehaviours zum AsyncBehaviour ähnlich der Xenko-Scripts SyncScript und AsyncScript.

Leider habe ich bereits einige Änderungen an den AsyncTools von alexzzzz gemacht, weswegen ich nur Teile meines Skripts verteilen kann. Ich hoffe, jeder kann daraus noch etwas lernen!

AsyncBehaviour.cs

[Serializable]
public partial class AsyncBehaviour : MonoBehaviour
{
    public T AddComponent<T>()
        where T : Component
    {
        return gameObject.AddComponent<T>();
    }

    public Component AddComponent(Type type)
    {
        return gameObject.AddComponent(type);
    }

    public async Task<Component> AddComponentAsync(Type type)
    {
        await MainThread;
        return gameObject.AddComponent(type);
    }

    public async Task<T> AddComponentAsync<T>()
        where T : Component
    {
        await MainThread;
        return gameObject.AddComponent<T>();
    }

    public async Task<T> GetComponentAsync<T>()
    {
        await MainThread;
        return GetComponent<T>();
    }

    public async Task<T[]> GetComponentsAsync<T>()
    {
        await MainThread;
        return GetComponents<T>();
    }

AsyncBehaviour.Properties.cs

public partial class AsyncBehaviour
{
    public static AsyncTools.Awaiter ToFixedUpdate => AsyncTools.ToFixedUpdate();
    public static TaskScheduler FixedUpdateScheduler => UnityScheduler.FixedUpdateScheduler;
    public static bool IsMainThread => AsyncTools.IsMainThread();
    public static AsyncTools.Awaiter ToLateUpdate => AsyncTools.ToLateUpdate();
    public static TaskScheduler LateUpdateScheduler => UnityScheduler.LateUpdateScheduler;
    public static AsyncTools.Awaiter ToThreadPool => AsyncTools.ToThreadPool();
    public static TaskScheduler ThreadPoolScheduler => UnityScheduler.ThreadPoolScheduler;
    public static AsyncTools.Awaiter ToUpdate => AsyncTools.ToUpdate();
    public static TaskScheduler UpdateScheduler => UnityScheduler.UpdateScheduler;

    public static Task RunMainThread(Action action)
    {
        return Task.Factory.StartNew(action, CancellationToken.None, TaskCreationOptions.None, UpdateScheduler);
    }

    public static Task<T> RunMainThread<T>(Func<T> func)
    {
        return Task.Factory.StartNew(func, CancellationToken.None, TaskCreationOptions.None, UpdateScheduler);
    }

    public static Task RunMainThread(Action action, CancellationToken cancellationToken)
    {
        return Task.Factory.StartNew(action, cancellationToken, TaskCreationOptions.None, UpdateScheduler);
    }

    public static Task<T> RunMainThread<T>(Func<T> func, CancellationToken cancellationToken)
    {
        return Task.Factory.StartNew(func, cancellationToken, TaskCreationOptions.None, UpdateScheduler);
    }
}   

Die erlaubt es nun, innerhalb eines jeden Scripts einen Großteil der Funktionen zu nutzen, die sonst nur über lange Member-Zugriffe verfügbar oder redundant wären.

Soviel von mir heute dazu.