Что такое Promise?

Понятие Promise (Обещание) в асинхронном программировании

Promise (Обещание) — это специализированный объект в JavaScript и TypeScript (включая среду выполнения Node.js), предназначенный для работы с асинхронными операциями. Он представляет собой обертку для значения, которое может быть доступно сейчас, в будущем или никогда. Основная цель Promise — предоставить более чистый и управляемый способ работы с асинхронным кодом по сравнению с традиционными callback-функциями, устраняя "ад колбэков".

Promise может находиться в одном из трех состояний:

• Pending (ожидание): начальное состояние, операция еще не завершена.
• Fulfilled (выполнено): операция успешно завершена, и Promise содержит результирующее значение.
• Rejected (отклонено): операция завершилась с ошибкой.

Основные принципы работы Promise

Создание Promise

Promise создается с помощью конструктора new Promise(), который принимает функцию-исполнитель с двумя параметрами: resolve и reject. Эти функции используются для изменения состояния Promise.

const myPromise = new Promise((resolve, reject) => {
    // Асинхронная операция (например, запрос к API)
    setTimeout(() => {
        const success = true;
        if (success) {
            resolve('Данные успешно получены');
        } else {
            reject(new Error('Ошибка при получении данных'));
        }
    }, 1000);
});

Обработка результатов через then(), catch() и finally()

Promise предоставляет цепочку методов для обработки результатов:

myPromise
    .then((result) => {
        console.log(result); // Выполнится при успешном resolve
    })
    .catch((error) => {
        console.error(error); // Выполнится при reject
    })
    .finally(() => {
        console.log('Операция завершена'); // Выполнится всегда
    });

Ключевые преимущества Promise

• Избавление от callback hell: Promise позволяют организовывать асинхронный код в плоские цепочки вместо глубоко вложенных колбэков.
• Четкое разделение успешного и ошибочного сценариев: через then() и catch().
• Возможность комбинирования: с помощью статических методов Promise.all(), Promise.race(), Promise.allSettled() и Promise.any().

// Пример использования Promise.all()
const promise1 = fetch('/api/data1');
const promise2 = fetch('/api/data2');

Promise.all([promise1, promise2])
    .then((results) => {
        const [result1, result2] = results;
        console.log('Обе операции завершены', result1, result2);
    })
    .catch((error) => {
        console.error('Хотя бы одна операция завершилась ошибкой', error);
    });

Promise в контексте C# и .NET

Хотя термин Promise специфичен для JavaScript/TypeScript, в C# существует аналогичная концепция — Task из пространства имен System.Threading.Tasks. Task представляет асинхронную операцию и имеет схожие характеристики:

public async Task<string> GetDataAsync()
{
    // Асинхронная операция
    var data = await httpClient.GetStringAsync("https://api.example.com/data");
    return data;
}

// Использование с обработкой результатов
GetDataAsync()
    .ContinueWith(task => {
        if (task.IsCompletedSuccessfully)
        {
            Console.WriteLine(task.Result);
        }
        else if (task.IsFaulted)
        {
            Console.Error.WriteLine(task.Exception.Message);
        }
    });

Ключевые сходства между Promise и Task:

• Представляют будущий результат асинхронной операции
• Поддерживают цепочки обработки (с помощью await в C# и .then() в JS)
• Имеют механизмы обработки ошибок
• Позволяют комбинировать несколько асинхронных операций

Эволюция до async/await

И в JavaScript/TypeScript, и в C# Promise/Task стали фундаментом для более высокоуровневого синтаксиса async/await:

// C# пример с async/await
public async Task ProcessDataAsync()
{
    try
    {
        string data = await GetDataAsync();
        Console.WriteLine($"Получены данные: {data}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Ошибка: {ex.Message}");
    }
}

// JavaScript пример с async/await
async function processData() {
    try {
        const data = await fetchData();
        console.log(`Получены данные: ${data}`);
    } catch (error) {
        console.error(`Ошибка: ${error.message}`);
    }
}

Практическое применение в C# Backend

В C# Backend разработке Task (аналог Promise) используется повсеместно:

• Web API контроллеры: асинхронные методы обработки HTTP-запросов
• Взаимодействие с БД: асинхронные операции Entity Framework Core
• Внешние HTTP-вызовы: через HttpClient
• Фоновые задачи: в сочетании с BackgroundService

// Пример асинхронного Web API контроллера в ASP.NET Core
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;
    
    [HttpGet("{id}")]
    public async Task<ActionResult<UserDto>> GetUser(int id)
    {
        var user = await _userService.GetUserByIdAsync(id);
        
        if (user == null)
            return NotFound();
            
        return Ok(user);
    }
}

Promise в JavaScript/TypeScript и его аналоги в других языках (особенно Task в C#) революционизировали подход к асинхронному программированию, сделав код более читаемым, поддерживаемым и менее подверженным ошибкам, связанным с конкурентным выполнением операций.