Вивчайте Introduction to Async and Await | Async/Await Fundamentals and Converting Sync to Async

Asynchronous programming is a powerful approach to writing programs that can do more than one thing at a time. Imagine you're cooking several dishes for a dinner party. If you wait for the pasta to boil before you start chopping vegetables, you'll waste a lot of time just standing around. Instead, you can start the pasta, then chop veggies while it cooks, and maybe even set the table while waiting for the oven to preheat. This is the essence of asynchronous programming: letting your program handle other tasks while waiting for something time-consuming to finish, such as reading a file, accessing a database, or calling a web service.

In traditional synchronous code, your program waits for each operation to finish before moving to the next one. This can make applications slow or unresponsive, especially when dealing with operations that take time. The async and await keywords in C# help you write code that is easier to read and maintain, while still running efficiently and responsively. By using asynchronous programming, you can keep your applications fast and responsive, even when performing long-running tasks.

Definition

Asynchronous programming is a way of writing code that allows operations to run independently of the main program flow, so your application can continue working while waiting for tasks to finish. An awaitable is any object or method that can be used with the await keyword—typically, this means methods that return Task or Task<T>.

Program.cs


              123456789101112131415161718192021222324252627282930313233343536
            
using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Starting synchronous operation...");
            SynchronousOperation();
            Console.WriteLine("Synchronous operation finished.\n");

            Console.WriteLine("Starting asynchronous operation...");
            var task = AsynchronousOperation();
            task.Wait(); // Wait for async operation to complete
            Console.WriteLine("Asynchronous operation finished.");
        }

        public static void SynchronousOperation()
        {
            Console.WriteLine("Synchronous: Working...");
            Thread.Sleep(2000); // Simulate long-running work
            Console.WriteLine("Synchronous: Done!");
        }

        public static async Task AsynchronousOperation()
        {
            Console.WriteLine("Asynchronous: Working...");
            await Task.Delay(2000); // Simulate long-running work asynchronously
            Console.WriteLine("Asynchronous: Done!");
        }
    }
}

In the code above, you see two methods: SynchronousOperation and AsynchronousOperation. The synchronous method uses Thread.Sleep(2000) to pause the program for two seconds, simulating a long-running task. During this time, nothing else can happen—the program is blocked until the sleep finishes.

The asynchronous method, on the other hand, uses await Task.Delay(2000). This also waits for two seconds, but it does so without blocking the main thread. When you call AsynchronousOperation, the program can continue doing other work while it waits for the delay to finish. The async keyword marks the method as asynchronous, and the await keyword tells the method to pause at that point, but without blocking the rest of the program. This makes your applications more responsive, especially in user interfaces or servers that need to handle many requests at once.

AsyncExample.cs


              12345678910
            
// This is a general structure of an async method in C#.
// Not meant to be run as a standalone file.

public async Task<int> GetDataAsync()
{
    // Start an asynchronous operation
    int result = await SomeLongRunningTask();
    return result;
}

When you declare a method as async, you usually return either Task (if the method doesn't return a value) or Task<T> (if the method returns a value of type T). The async modifier enables the use of the await keyword inside the method. The await keyword can only be used with methods that return a Task or Task<T>, or other awaitable types.

Use async and await when you have operations that might take a long time to complete, such as I/O, network calls, or database queries. This helps keep your applications responsive and efficient. However, avoid using async/await for CPU-bound operations that run entirely in memory and finish quickly, as this can introduce unnecessary overhead. A common pitfall is forgetting to use await inside an async method, which can lead to unexpected behavior or unhandled exceptions. Always check that your async methods are properly awaited and that you handle exceptions appropriately.

Все було зрозуміло?

Дякуємо за ваш відгук!

Секція 1. Розділ 1

Запитати АІ

Запитайте про що завгодно або спробуйте одне із запропонованих запитань, щоб почати наш чат

Suggested prompts:

Can you give an example of how to use async and await in C#?

What are some common mistakes to avoid when using async and await?

When should I use synchronous vs asynchronous methods?

Свайпніть щоб показати меню