what will the runtime do when await something?

[ljzj2]

I want to ask that what the runtime will do ? waiting or doing something else?

forexample :

await Shell.Current.GoToAsync("../");

when I want to go to some page(or read database or others). what the thread will do?

yes I know it will await the page open and then goto `i+=1` and will it just wait?

so why we use await? if I do not use await and create a delegate then when the page is open then execute the delegate (i+=1) it is same right?

like the MVVM event.

I create a event and when the page is open the event will execute the i+=1

[huoyaoyuan]

what the thread will do?

There isn't the thread during await. The caller thread creates a pending task and immediately return to its caller, and do whatever it wants. For UI applications, the thread will return quickly and go back for listening UI events.

yes I know it will await the page open and then goto i+=1 and will it just wait?

Nothing waits for await. When the inner-most task is completed, it posts the continuation to thread pool, or a UI thread with Dispatcher, which can accept posted code.
Strictly speaking, for UI application, the UI thread is waiting for either a UI event (like mouse) or any posted code.

so why we use await? if I do not use await and create a delegate then when the page is open then execute the delegate (i+=1) it is same right?

This is called event-based asynchronous pattern.

You can check the (very detailed) post about how async/await really works. The posts also explains why async/await replaces other asynchronous patterns to become the major pattern in .NET.

[ljzj2]

I think it was you who misunderstand about `await.
before compile the compiler will split the code into different parts and then compile it. there is no task registered to os i/o manager.

if there is function in asp.net core

public async Task<int> Get(int id)
{
    id = 0;

   id= await db.Values.GetAsync(x => x.Id == id);

    id++;

    return id;
}

then it will be:

 public async Task<int> Get(int id)
 {
     int value = 0;

     void perform()
     {
         switch (value)
         {
             case 0:
                 id = 0;
                 value++;
                 perform();
                 break;
             case 1:
//I do not sure
                 db.Values.Get(x => x.Id == id).ContinueWith(() =>
                 {
                     value++;
                     perform();
                 });

// I do not sure if it will be this code:
ThreadPool.QueueUserWorkItem((obj) =>
{
    db.Values.Get(x => x.Id == id).ContinueWith(() =>
    {
        value++;
        perform();
    });
});
                 break;
             case 2:
                 id++;
                 break;
         }
     }

     perform();

     return id;
}

So what you say is not right .

[huoyaoyuan]

I have contributed deeply for a long term.

before compile the compiler will split the code into different parts and then compile it.

This is true.

there is no task registered to os i/o manager.

The outer code won't reach OS. However, the inner-most Task that suspends is usually managed by OS I/O manager.

// I do not sure if it will be this code:
ThreadPool.QueueUserWorkItem((obj) =>
{
db.Values.Get(x => x.Id == id).ContinueWith(() =>
{
value++;
perform();
});
});

This is NOT the case. Equivalent of QueueUserWorkItem is used for Task.Run, which is for async computing, not async I/O.
Some poor I/O provider may implement async support like this, but not the standard ones.
The aformentioned code is only the case when GetAsync is poorly implemented as Task.Run(() => Get(x)).

See the inner-most worker for File.ReadAsync:

runtime/src/libraries/System.Private.CoreLib/src/System/IO/RandomAccess.Windows.cs

Lines 245 to 341 in 41ec889

	internal static ValueTask<int> ReadAtOffsetAsync(SafeFileHandle handle, Memory<byte> buffer, long fileOffset,
	CancellationToken cancellationToken, OSFileStreamStrategy? strategy = null)
	{
	if (handle.IsAsync)
	{
	(SafeFileHandle.OverlappedValueTaskSource? vts, int errorCode) = QueueAsyncReadFile(handle, buffer, fileOffset, cancellationToken, strategy);
	if (vts is not null)
	{
	return new ValueTask<int>(vts, vts.Version);
	}
	if (errorCode == 0)
	{
	return ValueTask.FromResult(0);
	}
	return ValueTask.FromException<int>(Win32Marshal.GetExceptionForWin32Error(errorCode, handle.Path));
	}
	return AsyncOverSyncWithIoCancellation.InvokeAsync(static state =>
	{
	try
	{
	int result = ReadAtOffset(state.handle, state.buffer.Span, state.fileOffset);
	if (result != state.buffer.Length)
	{
	state.strategy?.OnIncompleteOperation(state.buffer.Length, result);
	}
	return result;
	}
	catch (Exception) when (state.strategy is not null)
	{
	state.strategy.OnIncompleteOperation(state.buffer.Length, 0);
	throw;
	}
	}, (handle, buffer, fileOffset, strategy), cancellationToken);
	}
	private static unsafe (SafeFileHandle.OverlappedValueTaskSource? vts, int errorCode) QueueAsyncReadFile(SafeFileHandle handle, Memory<byte> buffer, long fileOffset,
	CancellationToken cancellationToken, OSFileStreamStrategy? strategy)
	{
	handle.EnsureThreadPoolBindingInitialized();
	SafeFileHandle.OverlappedValueTaskSource vts = handle.GetOverlappedValueTaskSource();
	int errorCode = Interop.Errors.ERROR_SUCCESS;
	try
	{
	NativeOverlapped* nativeOverlapped = vts.PrepareForOperation(buffer, fileOffset, strategy);
	Debug.Assert(vts._memoryHandle.Pointer != null || buffer.IsEmpty);
	// Queue an async ReadFile operation.
	if (Interop.Kernel32.ReadFile(handle, (byte*)vts._memoryHandle.Pointer, buffer.Length, IntPtr.Zero, nativeOverlapped) == 0)
	{
	// The operation failed, or it's pending.
	errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle);
	if (errorCode == Interop.Errors.ERROR_IO_PENDING)
	{
	// Common case: IO was initiated, completion will be handled by callback.
	// Register for cancellation now that the operation has been initiated.
	vts.RegisterForCancellation(cancellationToken);
	}
	else if (IsEndOfFile(errorCode, handle, fileOffset))
	{
	// EOF on a pipe. Callback will not be called.
	// We clear the overlapped status bit for this special case (failure
	// to do so looks like we are freeing a pending overlapped later).
	nativeOverlapped->InternalLow = IntPtr.Zero;
	vts.Dispose();
	return (null, 0);
	}
	else
	{
	// Error. Callback will not be called.
	vts.Dispose();
	return (null, errorCode);
	}
	}
	}
	catch
	{
	vts.Dispose();
	throw;
	}
	finally
	{
	if (errorCode != Interop.Errors.ERROR_IO_PENDING && errorCode != Interop.Errors.ERROR_SUCCESS)
	{
	strategy?.OnIncompleteOperation(buffer.Length, 0);
	}
	}
	// Completion handled by callback.
	vts.FinishedScheduling();
	return (vts, -1);
	}

and the callback entry from OS I/O manager when it completes:

runtime/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.OverlappedValueTaskSource.Windows.cs

Lines 216 to 230 in 41ec889

	private static void IOCallback(uint errorCode, uint numBytes, NativeOverlapped* pOverlapped)
	{
	OverlappedValueTaskSource? vts = (OverlappedValueTaskSource?)ThreadPoolBoundHandle.GetNativeOverlappedState(pOverlapped);
	Debug.Assert(vts is not null);
	Debug.Assert(vts._overlapped == pOverlapped, "Overlaps don't match");
	// Set the value to a packed combination of the error code and number of bytes (plus a high-bit 1
	// to ensure the value we're setting is non-zero). If it was already non-0 (the common case), then
	// the call site already finished scheduling the async operation, in which case we're ready to complete.
	Debug.Assert(numBytes < int.MaxValue);
	if (Interlocked.Exchange(ref vts._result, (1ul << 63) | ((ulong)numBytes << 32) | errorCode) != 0)
	{
	vts.Complete(errorCode, numBytes);
	}
	}

[ljzj2]

I am sorry I am newbie can you explain the code I can not understand it

[huoyaoyuan]

QueueAsyncReadFile is the inner-most method when working in (optimal) async mode. It initiates an asynchrous file reading operation via ReadFile. The Windows I/O manager will typically start the operation in background and returns ERROR_IO_PENDING immediately. A callback (the "ContinueWith" part) is registered to Windows via NativeOverlapped. At the moment, the File.ReadAsync call is considered "awaiting" at the view of async method. The NativeOverlapped will be wrapped into OverlappedValueTaskSource then ValueTask and returned to the caller. No user thread is waiting for the I/O operation.
After the Windows I/O manager completes the operation, it will find the callback registered in NativeOverlapped. It then grab a thread from the pool associated with the NativeOverlapped, invokes the callback (IOCallback method) on that thread. The IOCallback method then processes the result, and invoke any ContinueWith registered with the ValueTask.

[huoyaoyuan]

If you prefer I can also explain in Chinese.

It's worthy to point out that DoSomething and DoSomethingAsync are totally unrelated methods in the view of compiler. It can never transfroms code using DoSomethingAsync to be DoSomething in any form. It can never insert calls of QueueUserWorkItem/Task.Run either. What it can insert is only the equivalent of ContinueWith.