Почему сделано так, что нельзя ожидать async void методы?

// Async!
async void MyVoidMethod()
{
   while (true) ;
}
 
MyVoidMethod();
Console.WriteLine("Кончил");

// Не void!
async Task MyVoidMethod()
{
    // Что-то делаем
 
   await SomeOtherWork();
 
   // Что-то еще делаем
}

Task MyVoidMethod()
{
   // Что-то делаем
 
   var awaitable = SomeOtherWork();
   var awaiter = awaitable.GetAwaiter();
   if (awaiter.IsCmpleted)
   {
      // Что-то еще делаем
   }
   else
   {
      Action continuation = () =>
      {
           // Что-то еще делаем
      };
      Task originalWorkWithRemainderOfThisMethod = awaitable.ContinueWith(continuation);
      return originalWorkWithRemainderOfThisMethod;
   }
}

Task MyVoidMethod()
{
   // Что-то делаем
 
   var awaitable = SomeOtherWork();
   var awaiter = awaitable.GetAwaiter();
   if (awaiter.IsCmpleted)
   {
      // Что-то еще делаем
   }
   else
   {
      Action continuation = () =>
      {
           // Что-то еще делаем
      };
   }
}

static async void ExceptionMethod()
{
    Console.WriteLine("ExceptionMethod, before sleep");
    await Task.Delay(1000);
    Console.WriteLine("ExceptionMethod, after sleep");
 
    throw new ArgumentException();
}
 
static async Task Main(string[] args)
{
    Console.WriteLine("Main, start");
    try
    {
        await Task.Run(ExceptionMethod);
    }
    catch (Exception ex)
    {
        Console.WriteLine(ex);
    }
    Console.WriteLine("Main, finish");
    Console.ReadLine();
}

void IAsyncStateMachine.MoveNext()
{
    int num = this.<>1__state;
    try
    {
        TaskAwaiter awaiter;
        if (num != 0)
        {
        
            awaiter = Task.Run(new Action(Program.ExceptionMethod)).GetAwaiter();
            if (!awaiter.IsCompleted)
            {
                this.<>1__state = 0;
                this.<>u__1 = awaiter;
                Program.<Main>d__10 <Main>d__ = this;
                this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Program.<Main>d__10>(ref awaiter, ref <Main>d__);
                return;
            }
        }
        else
        {
            awaiter = this.<>u__1;
            this.<>u__1 = default(TaskAwaiter);
            this.<>1__state = -1;
        }
        awaiter.GetResult();
        Console.WriteLine("Main, finish");
        Console.ReadLine();
    }
    catch (Exception exception)
    {
        this.<>1__state = -2;
        this.<>t__builder.SetException(exception);
        return;
    }
    this.<>1__state = -2;
    this.<>t__builder.SetResult();
}

void IAsyncStateMachine.MoveNext()
{
    int num = this.<>1__state;
    try
    {
        TaskAwaiter awaiter;
        if (num != 0)
        {
            Console.WriteLine("ExceptionMethod, before sleep");
            awaiter = Task.Delay(1000).GetAwaiter();
            if (!awaiter.IsCompleted)
            {
                this.<>1__state = 0;
                this.<>u__1 = awaiter;
                Program.<ExceptionMethod>d__9 <ExceptionMethod>d__ = this;
                this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Program.<ExceptionMethod>d__9>(ref awaiter, ref <ExceptionMethod>d__);
                return;
            }
        }
        else
        {
            awaiter = this.<>u__1;
            this.<>u__1 = default(TaskAwaiter);
            this.<>1__state = -1;
        }
        awaiter.GetResult();
        Console.WriteLine("ExceptionMethod, after sleep");
        throw new ArgumentException();
    }
    catch (Exception exception)
    {
        this.<>1__state = -2;
        this.<>t__builder.SetException(exception);
    }
}

void Whatever() { }
 
foreach (var item in Whatever()) // ???

private Task Task
{
    get
    {
        if (this.m_task == null)
        {
            this.m_task = new Task();
        }
        return this.m_task;
    }
}

public Foo()
{
   DoSomethingAsync();
}