task_scheduler.h

 
#pragma once
 
#include <system/object.h>
#include <system/collections/list.h>
#include <functional>
 
namespace System { namespace Threading { namespace Tasks {
 
class ASPOSECPP_SHARED_CLASS TaskScheduler : public Object
{
    using ThisType = TaskScheduler;
 
public:
    static ASPOSECPP_SHARED_API const SharedPtr<TaskScheduler>& get_Default();
    static ASPOSECPP_SHARED_API SharedPtr<TaskScheduler> get_Current();
    virtual ASPOSECPP_SHARED_API int32_t get_MaximumConcurrencyLevel() const;
    int32_t get_Id() const {return m_id;}
 
    static ASPOSECPP_SHARED_API SharedPtr<TaskScheduler> FromCurrentSynchronizationContext();
 
protected:
    TaskScheduler();
 
    friend Task;
 
    ASPOSECPP_SHARED_API bool TryExecuteTask(const SharedPtr<Task>&);
    virtual ASPOSECPP_SHARED_API bool TryExecuteTaskInline(const SharedPtr<Task>&, bool taskWasPreviouslyQueued) = 0;
    virtual ASPOSECPP_SHARED_API void QueueTask(const SharedPtr<Task>&);
    virtual ASPOSECPP_SHARED_API bool TryDequeue(const SharedPtr<Task>&);
 
    int32_t m_id;
 
    static int32_t m_next_id;
    static thread_local Task* m_current_task;
 
    SharedPtr<Collections::Generic::List<TaskPtr>> m_tasks;
    std::recursive_mutex m_tasks_guard;
};
 
ASPOSECPP_SHARED_API void DispatchCurrentContext();
 
}}} // namespace System::Threading::Tasks