// See https://aka.ms/new-console-template for more information
using System.Reflection.PortableExecutable;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
public class Program
{
    static async Task Main(string[] args)
    {

        var tes = new TestAsync();
        var task =await tes.Test();
        Console.ReadKey();
    }
}
public class TestAsync
{
    public async MyTask<int> Test()
    { 
        await MyTask<int>.Delay(1);
        return 100;
    }
}

[AsyncMethodBuilder(typeof(MyTaskBuilder<>))]
public class MyTask<T> : Task<T> where T : notnull
{
    public MyTask(Func<T> action) : base(action) 
    {
        Action = action;
    }

    public Task<T> Task { get; }
    public Func<T> Action { get; }

    //
    // 摘要:
    //     Gets an awaiter used to await this System.Threading.Tasks.Task`1.
    //
    // 返回结果:
    //     An awaiter instance.
    public new CustomAwaiter<T> GetAwaiter()
    { 
       var awaiter=new CustomAwaiter<T>(Action);
        return awaiter;
    }

    // 添加构造函数和其他功能代码
}
public class CustomAwaiter<T> : ICriticalNotifyCompletion
{
    public CustomAwaiter(Func<T> func)
    {
        Func = func;
    }
    public bool IsCompleted { get; set; }
    public Func<T> Func { get; }

    public void OnCompleted(Action continuation)
    {
        continuation();
        IsCompleted = true;
    }

    public void UnsafeOnCompleted(Action continuation)
    {
        continuation();
        IsCompleted = true;
    }
    public T GetResult()
    {
        return Func() ;
    }
}

public class MyTaskBuilder<T> where T:notnull
{
    private readonly AsyncTaskMethodBuilder<T> _builder = new AsyncTaskMethodBuilder<T>();
    private T Value;
    public static MyTaskBuilder<T> Create()
    {
        return new MyTaskBuilder<T>();
    }

    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
    {
        _builder.Start(ref stateMachine);
    }

    public void SetStateMachine(IAsyncStateMachine stateMachine)
    {
        _builder.SetStateMachine(stateMachine);
    }

    public void SetResult(T val)
    {
        Value = val;
        _builder.SetResult(val);
    }

    public void SetException(Exception exception)
    {
        _builder.SetException(exception);
    }
    public MyTask<T> Task
    {
        get
        {
            return new MyTask<T>(new Func<T>(() => Value));
        }
    }

    public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
        _builder.AwaitOnCompleted(ref awaiter, ref stateMachine);
    }

    public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : ICriticalNotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
        _builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
    }
}
public class StateMachine : IAsyncStateMachine
{
    public StateMachine()
    {
        
    }
    public void MoveNext()
    {
        throw new NotImplementedException();
    }

    public void SetStateMachine(IAsyncStateMachine stateMachine)
    {
        throw new NotImplementedException();
    }
}

    CustomAsyncStateMechine customAsyncStateMechine = new CustomAsyncStateMechine();
            customAsyncStateMechine.builder = AsyncTaskMethodBuilder<string>.Create();
            customAsyncStateMechine.State = -1;
            customAsyncStateMechine.builder.Start(ref customAsyncStateMechine);
            return customAsyncStateMechine.builder.Task;