Что такое метод Parse в C# и когда его использовать?

Ответ

Parse — это статический метод, доступный у многих встроенных типов-значений (int, double, DateTime, bool и т.д.) и некоторых других типов (например, Enum). Его задача — преобразовать строковое представление в экземпляр целевого типа.

Синтаксис и простой пример:

string numericString = "42";
int number = int.Parse(numericString); // number = 42

string dateString = "2023-12-25";
DateTime date = DateTime.Parse(dateString); // date = 25.12.2023 00:00:00

string boolString = "True";
bool flag = bool.Parse(boolString); // flag = true

Критически важный нюанс: Метод Parse кидает исключения при неудаче. Это его главное отличие от TryParse.

Ситуация (на примере int.Parse) Исключение
Строка null ArgumentNullException
Строка в неправильном формате ("abc") FormatException
Число выходит за диапазон типа ("9999999999" для int) OverflowException

Пример обработки ошибок:

public int SafeParseExample(string userInput)
{
    try
    {
        return int.Parse(userInput);
    }
    catch (FormatException)
    {
        Console.WriteLine($"Ошибка: '{userInput}' не является числом.");
        return 0; // Значение по умолчанию
    }
    catch (OverflowException)
    {
        Console.WriteLine($"Ошибка: число {userInput} вне диапазона int.");
        return 0;
    }
    // ArgumentNullException обычно не ловят здесь, а проверяют раньше.
}

Альтернатива — TryParse. Когда что использовать?

Критерий Parse TryParse
Поведение при ошибке Бросает исключение Возвращает bool, ошибка в out-параметре
Производительность Медленнее при частых ошибках (дорогие исключения) Быстрее, т.к. не использует исключения
Использование Когда строка гарантированно валидна (например, константа в коде, данные из доверенного источника) Когда данные приходят извне (пользовательский ввод, файл, сеть)

Правильный выбор — TryParse для ненадёжных данных:

// ПЛОХО: Если userInput может быть некорректным, это риск исключения.
// int age = int.Parse(txtAge.Text);

// ХОРОШО: Безопасный парсинг пользовательского ввода.
if (int.TryParse(txtAge.Text, out int age))
{
    // Успех, работаем с age
    Console.WriteLine($"Через год вам будет {age + 1}");
}
else
{
    // Обработка ошибки без try-catch
    Console.WriteLine("Пожалуйста, введите корректный возраст.");
}

// TryParse с разными типами и форматами
string salaryInput = "1,500.75";
if (double.TryParse(salaryInput, NumberStyles.Currency, CultureInfo.InvariantCulture, out double salary))
{
    // Учёт формата числа с разделителями и валюты
}

string today = "Monday";
if (Enum.TryParse<DayOfWeek>(today, out DayOfWeek day))
{
    // Успешный парсинг перечисления
}

Итог: Используйте Parse для жёстко закодированных или проверенных данных. Всегда используйте TryParse для данных, источник которых вы не контролируете полностью.

Ответ 18+ 🔞

А, ну вот, смотри, про этот твой Parse... Это ж как в анекдоте про Герасима и Муму, только в мире кода. Представь: есть у тебя строка — ну, просто текст, буквы там всякие. А тебе надо её превратить в число, дату, булево значение — да во что угодно, что в C# типом называется. Так вот, Parse — это такой Герасим, здоровый, сильный, но, блядь, прямолинейный до упора. Даёт ему барыня команду: «Преврати мне "42" в число!». Он берёт строку, смотрит — ага, цифры. «Муму!» — то есть, «Окей!» — и выдаёт тебе чистое int число 42. Красота.

Но вся соль, как всегда, в трагедии. Дай ему строку "сорок два" или, там, "абвгд" — он же нихуя не понимает! Он не может сказать: «Барыня, тут хуйня какая-то, не число». Нет! Он максималист, ёпта! Либо всё, либо ничего. Он просто, блядь, ебанётся об эту строку и упадёт замертво, то есть кинет исключение — FormatException. А если строка null? Да это вообще пиздец, ArgumentNullException в лицо. Передашь ему "9999999999999" для int — он аж взвоет от переполнения, OverflowException на весь двор.

Вот, смотри, как он героически и глупо пытается работать:

string numericString = "42";
int number = int.Parse(numericString); // Всё гут, number = 42. Муму жива.

string dateString = "2023-12-25";
DateTime date = DateTime.Parse(dateString); // Прекрасно, date = 25.12.2023. Праздник.

string boolString = "True";
bool flag = bool.Parse(boolString); // flag = true. Жизнь удалась.

А теперь подставь ему свинью:

public int SafeParseExample(string userInput)
{
    try
    {
        return int.Parse(userInput); // Герасим пошёл выполнять приказ.
    }
    catch (FormatException) // Упал, блядь, лицом в грязь.
    {
        Console.WriteLine($"Ошибка: '{userInput}' не является числом.");
        return 0; // Приходится самому разгребать.
    }
    catch (OverflowException) // Перестарался, гад.
    {
        Console.WriteLine($"Ошибка: число {userInput} вне диапазона int.");
        return 0;
    }
    // А про ArgumentNullException я молчу, его лучше заранее if'ом отсечь.
}

Ну и зачем так жить, спрашивается? Весь код в try-catch оборачивать, потому что пользователь — тот ещё распиздяй, может в поле возраста написать "старый как динозавр"? Нахуй такие сложности!

Поэтому умные люди придумали TryParse. Это уже не Герасим, а какой-нибудь хитрожопый управляющий. Подходит к нему барыня: «Слушай, вот тут строка, попробуй в число превратить, а то чую, что-то не то». Он не бросается сразу делать. Он осторожно так: «Ща, барыня, проверю». Потыкает строку палочкой, понюхает.

И возвращает не результат, а булево значение — получилось или нет. А само число, если получилось, выплевывает через out-параметр. Никаких исключений! Никакого шума! Чистая дипломатия.

// ЭТО ПИЗДЕЦ (но некоторые так пишут):
// int age = int.Parse(txtAge.Text); // Если пользователь ввёл "олень", будет тебе Хиросима в консоли.

// А ЭТО — ОЧЕНЬ ГРАМОТНО И БЕЗ СТРЕССА:
if (int.TryParse(txtAge.Text, out int age)) // Пробуем, не дергаясь.
{
    // Успех! Значит, строка была норм. Работаем с age.
    Console.WriteLine($"Через год вам будет {age + 1}"); // Всё чётко.
}
else
{
    // Не получилось. Спокойно сообщаем об ошибке.
    Console.WriteLine("Пожалуйста, введите корректный возраст, а не 'бессмертный'.");
    // Исключений нет, стектрейсы не летят, все довольны.
}

И ведь работает не только с int! С double, с DateTime, с Enum — со всеми, кто не дурак и реализовал этот метод.

string salaryInput = "1,500.75";
if (double.TryParse(salaryInput, NumberStyles.Currency, CultureInfo.InvariantCulture, out double salary))
{
    // Всё, зарплату распарсили с учётом валютного формата. Можно жить.
}

string today = "Monday";
if (Enum.TryParse<DayOfWeek>(today, out DayOfWeek day))
{
    // Да, сегодня понедельник, день тяжёлый. Но парсинг-то удался!
}

Так когда что использовать, чтобы не выглядеть идиотом?

  • Parse: Только когда ты на 150% уверен, что строка валидна. Типа, захардкоженная константа в твоём же коде ("127.0.0.1") или данные из надёжного, проверенного источника (не от пользователя, блять!). Это как дать задание Герасиму в идеальных условиях.
  • TryParse: ВСЕГДА, когда данные приходят извне. Пользователь ввёл? Файл прочитал? Из сети пришло? Из базы данных вытащил? Сразу TryParse. Без вариантов. Это твой спасательный круг от ебучих исключений и падений приложения.

Запомни раз и навсегда: Parse — это пафос и риск, TryParse — это прагматизм и безопасность. В 99% случаев тебе нужен второй вариант. Не будь Герасимом, топящим свою Муму из-за чужой прихоти. Будь тем самым хитрожопым управляющим, который всё проверяет и живёт спокойно.