/*CustomTask

*/

​

​

using System;

using System.Runtime.CompilerServices;

using System.Runtime.ExceptionServices;

using System.Threading;

using System.Threading.Tasks;

public class Program

{

    public async static Task Main()

    {

        var p=new Program();

//      var t=new CustomTask<int>(delegate{return 1;});

        Console.WriteLine(System.Environment.ProcessorCount);

        //t.Start();

        //await t;

//      t.ContinueWith(()=>{Console.Write("asdf");});

        //await t.ContinueWith<int>(r=>{ Console.WriteLine("CW"); return 5;});

        //t.Start();

        //Console.WriteLine(await t);

//      Console.WriteLine(t.GetResult());

        Console.WriteLine("Hello World");

        var t=p.GetString("HeLLO ");

        var tt=t.ContinueWith(r=>r.ToUpper());

        Console.WriteLine("Daffy");

        Console.WriteLine(await t);

        Console.WriteLine(await tt);

        Console.WriteLine("after call");

        Console.WriteLine(CustomTask<string>.totalTask);

        Console.WriteLine(CustomTask<string>.totalCompletedWithoutContinuation);

    }

    public async CustomTask<string> GetString(string s)

    {

        var t= new CustomTask<string>(()=>s+ "Bugs ");

        await Task.Delay(100);

        //await t;

        //Console.WriteLine("IN GET" + t.Result);

        //Console.WriteLine(t?.Result==null);

        //await t;

        Console.WriteLine($"In GetString: {t.Result}");

        return await t;

    }

}

​

[AsyncMethodBuilder(typeof(CustomTaskBuilder<>))]

public class CustomTask<T> 

{   

    internal static int totalTask=0;

    internal static int totalCompletedWithoutContinuation=0;

    private Func<T> function;

    private CustomTaskAwaiter<T> awaiter;

    private ValueTask<T> vTask;

    private Task<T> task;

    private TaskCompletionSource<T> tcs=new TaskCompletionSource<T>();

    TaskContinuationOptions tco=TaskContinuationOptions.DenyChildAttach | TaskContinuationOptions.ExecuteSynchronously;

    internal CustomTask(T fromResult) 

    {

        task=tcs.Task;

        tcs.SetResult(fromResult);

        initAwaiter(ref task);

    }

    public CustomTask(Func<T> f, bool continueOnCapturedContext=false) 

    {   

        function=f;

        TaskCreationOptions tCo=TaskCreationOptions.DenyChildAttach;

        task=Task<T>.Factory.StartNew(()=>f(), tCo);

        task.ConfigureAwait(continueOnCapturedContext);

        initAwaiter(ref task);

    }

    private void initAwaiter(ref Task<T> t) => awaiter=new CustomTaskAwaiter<T>(ref t);

    public CustomTaskAwaiter<T> GetAwaiter() => awaiter;//default(CustomTaskAwaiter<T>);//awaiter;

    public T Result {get=>GetAwaiter().GetResult();}

    public CustomTask<T> ContinueWith(Func<T,T> func) => (CustomTask<T>)task.ContinueWith<T>(antecedent=>func(antecedent.Result));  

    public CustomTask<OUT> ContinueWith<OUT>(Func<T, OUT> func) => (CustomTask<OUT>)task.ContinueWith<OUT>(antecedent=>func(antecedent.Result));    

    public static explicit operator CustomTask<T>(Task<T> task) => new CustomTask<T>(fromResult:task.Result);

    public static explicit operator CustomTask<T>(T result) => new CustomTask<T>(fromResult:result);

    public static explicit operator Task<T>(CustomTask<T> customTask) => customTask.task;

} 

public struct CustomTaskAwaiter<T> : INotifyCompletion

{   

    public Task<T> task;

    private bool isCompleted=false;

    public CustomTaskAwaiter(ref Task<T> t)

    {

        task=t;

    }

    public bool IsCompleted 

    { 

        get 

        {

            bool result=task.IsCompleted;

            Interlocked.Increment(ref CustomTask<T>.totalTask);

            if(result) Interlocked.Increment(ref CustomTask<T>.totalCompletedWithoutContinuation);

            //Console.WriteLine($"IsCompleted={task.IsCompleted}");

            //return true;

            return task.IsCompleted;// && isCompleted; 

        }    

    }

    public T GetResult() => task.Result;     

    public void OnCompleted(Action continuation)

    {   

        Console.WriteLine("Awaiter.OnCompleted");

        isCompleted=true;

        if (continuation!=null) continuation();

    }

}

​

public struct CustomTaskBuilder<T>

{    

//  private System.Threading.Tasks.TaskCompletionSource<T> tcs=new();

    public CustomTaskBuilder() => Console.WriteLine(".ctor");

    public static CustomTaskBuilder<T> Create() => new CustomTaskBuilder<T>();

    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine

    {

        Console.WriteLine("Start");

        stateMachine.MoveNext();

    }

    public CustomTask<T> Task {get;set;}=default(CustomTask<T>);

    public void SetResult(T result) 

    {

        Task=new CustomTask<T>(result);

        Console.WriteLine($"{result} In CustomTaskBuilder.SetResult");

    }

    // AwaitOnCompleted, AwaitUnsafeOnCompleted, SetException 

    // and SetStateMachine are empty

    public void SetStateMachine(IAsyncStateMachine stateMachine)

    {   //stateMachine.SetStateMachine(stateMachine); 

        this.SetStateMachine(stateMachine);

    }

    public void SetException(Exception exception) 

    {   

        ExceptionDispatchInfo.Throw(exception); 

    }

    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)        

        where TAwaiter : INotifyCompletion          

        where TStateMachine : IAsyncStateMachine 

    {   //awaiter.OnCompleted(null); 

        stateMachine.MoveNext();

    }

    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)

        where TAwaiter : INotifyCompletion        

        where TStateMachine : IAsyncStateMachine

    {   //awaiter.OnCompleted(null); 

        stateMachine.MoveNext();

    }

}

/*

public class MyThreadPool

{

    private static System.Collections.Concurrent.BlockingCollection<(Action, ExecutionContext?)> workItems=new();

    static MyThreadPool()

    {

        for(int i=0;i<System.Environment.ProcessorCount;i++)

        {

            new Thread(()=>{}){IsBackground=true}.Start();

            (Action a, ExecutionContext? context)=workItems.Take();

            if(context==null) a();

            else ExecutionContext.Run(context,state=>((Action)state!).Invoke(),a);

        }

    }

    public static void QueueWorkItem(Action a)

    {

        workItems.Add((a,ExecutionContext.Capture()));

    }

}

*/