Как разобрать строку на обнуляемое int

int.TryParse, наверное, немного проще:

public static int? ToNullableInt(this string s)
{
    int i;
    if (int.TryParse(s, out i)) return i;
    return null;
}

Изменить @Glenn int.TryParse "встроен в структуру". Он и int.Parse - это способ преобразования строк в целые числа.

Вы можете сделать это в одной строке, используя условный оператор и тот факт, что вы можете привести null к типу, допускающему значение NULL (две строки, если у вас нет уже существующего int, вы можете повторно использовать для вывода TryParse):

До C # 7:

int tempVal;
int? val = Int32.TryParse(stringVal, out tempVal) ? Int32.Parse(stringVal) : (int?)null;

С обновленным синтаксисом C # 7, который позволяет объявлять выходную переменную в вызове метода, это становится еще проще.

int? val = Int32.TryParse(stringVal, out var tempVal) ? tempVal : (int?)null;

[Обновлено для использования современного C # в соответствии с предложением @ sblom]

У меня была эта проблема, и я закончил с этим (в конце концов, if и 2 returns слишком длинны!):

int? ToNullableInt (string val)
    => int.TryParse (val, out var i) ? (int?) i : null;

Если серьезно, постарайтесь не смешивать int, ключевое слово C #, с Int32, которое является типом BCL .NET Framework - хотя это работает, код просто выглядит беспорядочным.

C# < 7.1

с использованием оператора по умолчанию

var result = int.TryParse(foo, out var f) ? f : default(int?);

C# >= 7.1

с использованием литерала по умолчанию

var result = int.TryParse(foo, out var f) ? f : default;

_{См. Управление версиями языка C # чтобы узнать, какую языковую версию поддерживает ваш проект}

Редактировать:

См. Для справки снимок экрана ниже (C # Interactive):

Источники:

• var
• Int32.TryParse
• условный оператор
• оператор по умолчанию (объяснено в this сообщение stackoverflow).
• тип значения, допускающего значение NULL

Гленн Славен: меня больше интересует, есть ли встроенный метод фреймворка, который будет выполнять синтаксический анализ непосредственно в int, допускающий значение NULL?

Существует этот подход, который будет анализировать непосредственно до обнуляемого int (а не только int), если значение допустимо, как null или пустая строка, но выдает исключение для недопустимых значений, поэтому вам нужно будет перехватить исключение и вернуть значение по умолчанию для таких ситуаций:

public static T Parse<T>(object value)
{
    try { return (T)System.ComponentModel.TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value.ToString()); }
    catch { return default(T); }
}

Этот подход все еще можно использовать для синтаксического анализа, не допускающего значения NULL, а также для анализа, допускающего значение NULL:

enum Fruit { Orange, Apple }
var res1 = Parse<Fruit>("Apple");
var res2 = Parse<Fruit?>("Banana");
var res3 = Parse<int?>("100") ?? 5; //use this for non-zero default
var res4 = Parse<Unit>("45%");

NB: в конвертере есть метод IsValid, который вы можете использовать вместо захвата исключения (выброшенные исключения действительно приводят к ненужные накладные расходы, если ожидается). К сожалению, он работает только с .NET 4, но все еще существует проблема, когда он не проверяет ваш языковой стандарт при проверке правильных форматов DateTime, см. ошибка 93559.

Попробуй это:

public static int? ParseNullableInt(this string value)
{
    int intValue;
    if (int.TryParse(value, out intValue))
        return intValue;
    return null;
}

Старая тема, а как насчет:

public static int? ParseToNullableInt(this string value)
{
     return String.IsNullOrEmpty(value) ? null : (int.Parse(value) as int?);
}

Мне это больше нравится, так как требование, где разбирать null, версия TryParse не выдает ошибку, например. ToNullableInt32 (XXX). Это может привести к нежелательным скрытым ошибкам.

Я считаю, что мое решение - очень чистое и красивое:

public static T? NullableParse<T>(string s) where T : struct
{
    try
    {
        return (T)typeof(T).GetMethod("Parse", new[] {typeof(string)}).Invoke(null, new[] { s });
    }
    catch (Exception)
    {
        return null;
    }
}

Это, конечно, общее решение, которое требует только, чтобы аргумент generics имел статический метод "Parse (string)". Это работает для чисел, логических значений, DateTime и т. Д.

Все остальные ответы можно забыть - есть отличное универсальное решение: http://cleansharp.de/wordpress/2011/05/generischer-typeconverter/

Это позволяет вам писать очень чистый код, например:

string value = null;
int? x = value.ConvertOrDefault();

а также:

object obj = 1;  

string value = null;
int x = 5;
if (value.TryConvert(out x))
    Console.WriteLine("TryConvert example: " + x); 

bool boolean = "false".ConvertOrDefault();
bool? nullableBoolean = "".ConvertOrDefault();
int integer = obj.ConvertOrDefault();
int negativeInteger = "-12123".ConvertOrDefault();
int? nullableInteger = value.ConvertOrDefault();
MyEnum enumValue = "SecondValue".ConvertOrDefault();

MyObjectBase myObject = new MyObjectClassA();
MyObjectClassA myObjectClassA = myObject.ConvertOrDefault();

Следующее должно работать для любого типа структуры. Он основан на коде Мэтт Манела с форумов MSDN. Как указывает Мерф, обработка исключений может быть дорогостоящей по сравнению с использованием специального метода TryParse для типов.

        public static bool TryParseStruct<T>(this string value, out Nullable<T> result)
            where T: struct 
        {
            if (string.IsNullOrEmpty(value))
            {
                result = new Nullable<T>();

                return true;
            }

            result = default(T);
            try
            {
                IConvertible convertibleString = (IConvertible)value;
                result = new Nullable<T>((T)convertibleString.ToType(typeof(T), System.Globalization.CultureInfo.CurrentCulture));
            }
            catch(InvalidCastException)
            {
                return false;
            }
            catch (FormatException)
            {
                return false;
            }

           return true;
        }

Это были основные тестовые примеры, которые я использовал.

        string parseOne = "1";
        int? resultOne;
        bool successOne = parseOne.TryParseStruct<int>(out resultOne);
        Assert.IsTrue(successOne);
        Assert.AreEqual(1, resultOne);

        string parseEmpty = string.Empty;
        int? resultEmpty;
        bool successEmpty = parseEmpty.TryParseStruct<int>(out resultEmpty);
        Assert.IsTrue(successEmpty);
        Assert.IsFalse(resultEmpty.HasValue);

        string parseNull = null;
        int? resultNull;
        bool successNull = parseNull.TryParseStruct<int>(out resultNull);
        Assert.IsTrue(successNull);
        Assert.IsFalse(resultNull.HasValue);

        string parseInvalid = "FooBar";
        int? resultInvalid;
        bool successInvalid = parseInvalid.TryParseStruct<int>(out resultInvalid);
        Assert.IsFalse(successInvalid);

Я бы предложил следующие методы расширения для синтаксического анализа строки в значение int с возможностью определения значения по умолчанию в случае, если синтаксический анализ невозможен:

public static int ParseInt(this string value, int defaultIntValue = 0)
        {
            return int.TryParse(value, out var parsedInt) ? parsedInt : defaultIntValue;
        }

public static int? ParseNullableInt(this string value)
        {
            if (string.IsNullOrEmpty(value))
                return null;

            return value.ParseInt();
        }

Мне больше интересно узнать, есть ли встроенный метод фреймворка, который будет анализировать непосредственно в int, допускающий значение NULL?

Нет.

Это универсальное решение без накладных расходов на отражение.

public static Nullable<T> ParseNullable<T>(string s, Func<string, T> parser) where T : struct
{
    if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(s.Trim())) return null;
    else return parser(s);
}

static void Main(string[] args)
{
    Nullable<int> i = ParseNullable("-1", int.Parse);
    Nullable<float> dt = ParseNullable("3.14", float.Parse);
}

Я чувствовал, что должен поделиться своим, более общим.

Использование:

var result = "123".ParseBy(int.Parse);

var result2 = "123".ParseBy<int>(int.TryParse);

Решение:

public static class NullableParse
{
    public static Nullable<T> ParseBy<T>(this string input, Func<string, T> parser)
        where T : struct
    {
        try
        {
            return parser(input);
        }
        catch (Exception exc)
        {
            return null;
        }
    }

    public delegate bool TryParseDelegate<T>(string input, out T result);

    public static Nullable<T> ParseBy<T>(this string input, TryParseDelegate<T> parser)
        where T : struct
    {
        T t;
        if (parser(input, out t)) return t;
        return null;
    }
}

Первая версия работает медленнее, так как требует попытки уловить, но выглядит чище. Если он не будет вызываться много раз с недопустимыми строками, это не так важно. Если производительность является проблемой, обратите внимание, что при использовании методов TryParse вам необходимо указать параметр типа ParseBy, поскольку он не может быть выведен компилятором. Мне также пришлось определить делегат, поскольку ключевое слово out не может использоваться в Func ‹>, но, по крайней мере, на этот раз компилятор не требует явного экземпляра.

Наконец, вы можете использовать его и с другими структурами, например, decimal, DateTime, Guid и т. Д.

Я нашел и адаптировал код для класса Generic NullableParser. Полный код находится в моем блоге Nullable TryParse

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
namespace SomeNamespace
{
    /// <summary>
    /// A parser for nullable types. Will return null when parsing fails.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    ///
    public static class NullableParser<T> where T : struct
    {
        public delegate bool TryParseDelegate(string s, out T result);
        /// <summary>
        /// A generic Nullable Parser. Supports parsing of all types that implements the tryParse method;
        /// </summary>
        /// <param name="text">Text to be parsed</param>
        /// <param name="result">Value is true for parse succeeded</param>
        /// <returns>bool</returns>
        public static bool TryParse(string s, out Nullable<T> result)
        {
            bool success = false;
            try
            {
                if (string.IsNullOrEmpty(s))
                {
                    result = null;
                    success = true;
                }
                else
                {
                    IConvertible convertableString = s as IConvertible;
                    if (convertableString != null)
                    {
                        result = new Nullable<T>((T)convertableString.ToType(typeof(T),
                            CultureInfo.CurrentCulture));
                        success = true;
                    }
                    else
                    {
                        success = false;
                        result = null;
                    }
                }
            }
            catch
            {
                success = false;
                result = null;
            }
            return success;
        }
    }
}

Вы не должны никогда использовать исключение, если вам не нужно - накладные расходы ужасны.

Варианты TryParse решают проблему - если вы хотите проявить творческий подход (чтобы ваш код выглядел более элегантно), вы, вероятно, могли бы что-то сделать с помощью метода расширения в 3.5, но код будет более или менее таким же.

Используя делегаты, следующий код может обеспечить возможность повторного использования, если вам потребуется синтаксический анализ, допускающий значение NULL, для более чем одного типа структуры. Я показал здесь обе версии .Parse () и .TryParse ().

Это пример использования:

NullableParser.TryParseInt(ViewState["Id"] as string);

И вот код, который приведет вас туда ...

public class NullableParser
  {
    public delegate T ParseDelegate<T>(string input) where T : struct;
    public delegate bool TryParseDelegate<T>(string input, out T outtie) where T : struct;
    private static T? Parse<T>(string input, ParseDelegate<T> DelegateTheParse) where T : struct
    {
      if (string.IsNullOrEmpty(input)) return null;
      return DelegateTheParse(input);
    }
    private static T? TryParse<T>(string input, TryParseDelegate<T> DelegateTheTryParse) where T : struct
    {
      T x;
      if (DelegateTheTryParse(input, out x)) return x;
      return null;
    }
    public static int? ParseInt(string input)
    {
      return Parse<int>(input, new ParseDelegate<int>(int.Parse));
    }
    public static int? TryParseInt(string input)
    {
      return TryParse<int>(input, new TryParseDelegate<int>(int.TryParse));
    }
    public static bool? TryParseBool(string input)
    {
      return TryParse<bool>(input, new TryParseDelegate<bool>(bool.TryParse));
    }
    public static DateTime? TryParseDateTime(string input)
    {
      return TryParse<DateTime>(input, new TryParseDelegate<DateTime>(DateTime.TryParse));
    }
  }

Я понимаю, что это старая тема, но не могли бы вы просто:

(Nullable<int>)int.Parse(stringVal);

?

Я придумал этот, который удовлетворил мои требования (я хотел, чтобы мой метод расширения как можно ближе имитировал возврат TryParse фреймворка, но без блоков try {} catch {} и без жалоб компилятора на вывод обнуляемый тип в рамках метода)

private static bool TryParseNullableInt(this string s, out int? result)
{
    int i;
    result = int.TryParse(s, out i) ? (int?)i : null;
    return result != null;
}

Я предлагаю код ниже. Вы можете работать с исключением, когда произошла ошибка конвертации.

public static class Utils {      
public static bool TryParse<Tin, Tout>(this Tin obj, Func<Tin, Tout> onConvert, Action<Tout> onFill, Action<Exception> onError) {
  Tout value = default(Tout);
  bool ret = true;
  try {
    value = onConvert(obj);
  }
  catch (Exception exc) {
    onError(exc);
    ret = false;
  }
  if (ret)
    onFill(value);
  return ret;
}

public static bool TryParse(this string str, Action<int?> onFill, Action<Exception> onError) {
  return Utils.TryParse(str
    , s => string.IsNullOrEmpty(s) ? null : (int?)int.Parse(s)
    , onFill
    , onError);
}
public static bool TryParse(this string str, Action<int> onFill, Action<Exception> onError) {
  return Utils.TryParse(str
    , s => int.Parse(s)
    , onFill
    , onError);
}
}

Используйте этот метод расширения в коде (заполните свойство int? Age класса человека):

string ageStr = AgeTextBox.Text;
Utils.TryParse(ageStr, i => person.Age = i, exc => { MessageBox.Show(exc.Message); });

OR

AgeTextBox.Text.TryParse(i => person.Age = i, exc => { MessageBox.Show(exc.Message); });