S>async Task<int> SumAsync(int a, int b) {
S>    return a + b;
S>}

S>var x = await SumAsync(2, 3);
S>

func sum(a, b int) int {
    return a + b
}

x := sum(1, 2)

По умолчанию вызов функции в Go — синхронный: выполняется в текущей горутине и возвращает управление только после return

async Task<int> SumAsync(int a, int b) {
    return a + b;
}

var x = await SumAsync(2, 3);

func sum(a, b int) int {
    return a + b
}
x := sum(1, 2)

// Вот моя асинхронная функция
func sum(a, b int) int {
    return a + b
}

// Я могу вызвать ее и дождаться результата (поток ОС при этом не блокируется)
x := sum(1, 2)

// Я могу вызвать и не дожидаться результата (при этом несмотря на создание новой горутины, это может все работать на одном единственном потоке ОС)
go sum(1, 2)

// В крайне редких кейзах, когда мне не нужен результат прям сейчас, а нужен когда-то потом, то я могу написать
result := make(chan int)
go func(){result <- sum(1,2)}()
... куча кода
println(<-result)

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Program
{
    // Глобальный счетчик (общий ресурс для всех потоков)
    private static int _globalCounter = 0;

    public static async Task Main()
    {
        // Список для хранения запущенных задач (аналог Future/Promise)
        var tasks = new List<Task<int>>();
        int numberOfTasks = 10;

        Console.WriteLine("--- 1. Запуск задач ---");

        for (int i = 0; i < numberOfTasks; i++)
        {
            // Task.Run ставит задачу в очередь ThreadPool.
            // Мы НЕ используем await здесь, чтобы не блокировать цикл.
            // Мы просто сохраняем "хэндл" задачи в список.
            Task<int> task = Task.Run(async () =>
            {
                // Имитация работы (задержка 100мс), чтобы потоки точно работали параллельно
                await Task.Delay(100);

                // Атомарное увеличение счетчика. 
                // Это аналог counter++ только потокобезопасный.
                // Функция возвращает уже увеличенное значение.
                return Interlocked.Increment(ref _globalCounter);
            });

            tasks.Add(task);
        }

        Console.WriteLine($"Запущено {tasks.Count} задач. Главный поток свободен и продолжает работу...");
        
        // Здесь можно делать что-то еще, пока таски крутятся в фоне
        
        Console.WriteLine("--- 2. Ожидание выполнения ---");

        // Task.WhenAll эффективно ждет завершения всех задач из списка.
        // Он возвращает массив результатов, когда последний таск закончит работу.
        int[] results = await Task.WhenAll(tasks);

        Console.WriteLine("Все задачи завершены!");
        Console.WriteLine("--- 3. Вывод результатов ---");

        // Проходимся по полученным результатам
        // Порядок в массиве results соответствует порядку задач в списке tasks
        for (int i = 0; i < results.Length; i++)
        {
            Console.WriteLine($"Таск #{i + 1} вернул значение счетчика: {results[i]}");
        }
        
        Console.WriteLine($"Итоговое значение глобального счетчика: {_globalCounter}");
    }
}

Горутина #1 вернула значение счетчика: 6
Горутина #2 вернула значение счетчика: 2
Горутина #3 вернула значение счетчика: 7
Горутина #4 вернула значение счетчика: 5
Горутина #5 вернула значение счетчика: 1
Горутина #6 вернула значение счетчика: 3
Горутина #7 вернула значение счетчика: 10
Горутина #8 вернула значение счетчика: 9
Горутина #9 вернула значение счетчика: 8
Горутина #10 вернула значение счетчика: 4
Итоговое значение глобального счетчика: 10