Определите, является ли строка числом

Если у меня есть эти строки:

1. "abc" знак равно false

2. "123" знак равно true

3. "ab2" знак равно false

Есть ли команда, например IsNumeric()или что-то еще, которая может определить, является ли строка допустимым числом?

int n;
bool isNumeric = int.TryParse("123", out n);

Обновление от C # 7:

var isNumeric = int.TryParse("123", out int n);

или если вам не нужен номер, вы можете сбросить параметр out

var isNumeric = int.TryParse("123", out _);

В вар s могут быть заменены их соответствующими типами!

Это вернет true, если inputвсе числа. Не знаю, лучше ли это TryParse, но это сработает.

Regex.IsMatch(input, @"^\d+$")

Если вы просто хотите узнать, есть ли в нем одно или несколько чисел, смешанных с символами, не указывайте ^ +и $.

Regex.IsMatch(input, @"\d")

Изменить: На самом деле я думаю, что это лучше, чем TryParse, потому что очень длинная строка может потенциально переполнить TryParse.

Вы также можете использовать:

stringTest.All(char.IsDigit);

Он вернется trueдля всех числовых цифр (не float) и, falseесли входная строка будет какой-либо буквенно-цифровой.

Обратите внимание : stringTestне должно быть пустой строкой, так как это пройдет проверку на числовость.

Я использовал эту функцию несколько раз:

public static bool IsNumeric(object Expression)
{
    double retNum;

    bool isNum = Double.TryParse(Convert.ToString(Expression), System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
    return isNum;
}

Но вы также можете использовать;

bool b1 = Microsoft.VisualBasic.Information.IsNumeric("1"); //true
bool b2 = Microsoft.VisualBasic.Information.IsNumeric("1aa"); // false

Из бенчмаркинга есть числовые параметры

_{(источник: aspalliance.com )}

_{(источник: aspalliance.com )}

Это, вероятно, лучший вариант в C #.

Если вы хотите узнать, содержит ли строка целое число (целое число):

string someString;
// ...
int myInt;
bool isNumerical = int.TryParse(someString, out myInt);

Метод TryParse попытается преобразовать строку в число (целое число) и, если это удастся, вернет true и поместит соответствующее число в myInt. Если это невозможно, возвращается false.

Решения, использующие int.Parse(someString)альтернативу, показанную в других ответах, работают, но они намного медленнее, потому что выбрасывать исключения очень дорого. TryParse(...)был добавлен в язык C # в версии 2, и до этого у вас не было выбора. Теперь вы делаете: вы должны избегать Parse()альтернативы.

Если вы хотите принять десятичные числа, у десятичного класса также есть .TryParse(...)метод. Замените int на десятичное в приведенном выше обсуждении, и те же принципы применяются.

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

Пример.

decimal myDec;
var Result = decimal.TryParse("123", out myDec);

Результат будет тогда = True

decimal myDec;
var Result = decimal.TryParse("abc", out myDec);

Результат будет тогда = Ложь

В случае, если вы не хотите использовать int.Parse или double.Parse, вы можете сделать что-то вроде этого:

public static class Extensions
{
    public static bool IsNumeric(this string s)
    {
        foreach (char c in s)
        {
            if (!char.IsDigit(c) && c != '.')
            {
                return false;
            }
        }

        return true;
    }
}

Если вы хотите поймать более широкий спектр чисел, в PHP is_numeric , вы можете использовать следующее:

// From PHP documentation for is_numeric
// (http://php.net/manual/en/function.is-numeric.php)

// Finds whether the given variable is numeric.

// Numeric strings consist of optional sign, any number of digits, optional decimal part and optional
// exponential part. Thus +0123.45e6 is a valid numeric value.

// Hexadecimal (e.g. 0xf4c3b00c), Binary (e.g. 0b10100111001), Octal (e.g. 0777) notation is allowed too but
// only without sign, decimal and exponential part.
static readonly Regex _isNumericRegex =
    new Regex(  "^(" +
                /*Hex*/ @"0x[0-9a-f]+"  + "|" +
                /*Bin*/ @"0b[01]+"      + "|" + 
                /*Oct*/ @"0[0-7]*"      + "|" +
                /*Dec*/ @"((?!0)|[-+]|(?=0+\.))(\d*\.)?\d+(e\d+)?" + 
                ")$" );
static bool IsNumeric( string value )
{
    return _isNumericRegex.IsMatch( value );
}

Модульный тест:

static void IsNumericTest()
{
    string[] l_unitTests = new string[] { 
        "123",      /* TRUE */
        "abc",      /* FALSE */
        "12.3",     /* TRUE */
        "+12.3",    /* TRUE */
        "-12.3",    /* TRUE */
        "1.23e2",   /* TRUE */
        "-1e23",    /* TRUE */
        "1.2ef",    /* FALSE */
        "0x0",      /* TRUE */
        "0xfff",    /* TRUE */
        "0xf1f",    /* TRUE */
        "0xf1g",    /* FALSE */
        "0123",     /* TRUE */
        "0999",     /* FALSE (not octal) */
        "+0999",    /* TRUE (forced decimal) */
        "0b0101",   /* TRUE */
        "0b0102"    /* FALSE */
    };

    foreach ( string l_unitTest in l_unitTests )
        Console.WriteLine( l_unitTest + " => " + IsNumeric( l_unitTest ).ToString() );

    Console.ReadKey( true );
}

Имейте в виду, что только то, что значение является числовым, не означает, что его можно преобразовать в числовой тип. Например, "999999999999999999999999999999.9999999999"это допустимое числовое значение perfeclty, но оно не вписывается в числовой тип .NET (то есть не определенный в стандартной библиотеке).

Я знаю, что это старая ветка, но ни один из ответов на самом деле не сделал это для меня - ни неэффективно, либо не заключено в капсулу для легкого повторного использования. Я также хотел убедиться, что он вернул false, если строка была пустой или нулевой. TryParse возвращает true в этом случае (пустая строка не вызывает ошибку при разборе как числа). Итак, вот мой метод расширения строки:

public static class Extensions
{
    /// <summary>
    /// Returns true if string is numeric and not empty or null or whitespace.
    /// Determines if string is numeric by parsing as Double
    /// </summary>
    /// <param name="str"></param>
    /// <param name="style">Optional style - defaults to NumberStyles.Number (leading and trailing whitespace, leading and trailing sign, decimal point and thousands separator) </param>
    /// <param name="culture">Optional CultureInfo - defaults to InvariantCulture</param>
    /// <returns></returns>
    public static bool IsNumeric(this string str, NumberStyles style = NumberStyles.Number,
        CultureInfo culture = null)
    {
        double num;
        if (culture == null) culture = CultureInfo.InvariantCulture;
        return Double.TryParse(str, style, culture, out num) && !String.IsNullOrWhiteSpace(str);
    }
}

Прост в использовании:

var mystring = "1234.56789";
var test = mystring.IsNumeric();

Или, если вы хотите проверить другие типы чисел, вы можете указать «стиль». Итак, чтобы преобразовать число с экспонентой, вы можете использовать:

var mystring = "5.2453232E6";
var test = mystring.IsNumeric(style: NumberStyles.AllowExponent);

Или для проверки потенциальной шестнадцатеричной строки вы можете использовать:

var mystring = "0xF67AB2";
var test = mystring.IsNumeric(style: NumberStyles.HexNumber)

Необязательный параметр 'culture' может использоваться почти таким же образом.

Он ограничен тем, что не может преобразовать строки, которые слишком велики, чтобы их можно было заключить в двойные числа, но это ограниченное требование, и я думаю, что если вы работаете с числами, большими, чем эта, то вам, вероятно, потребуется дополнительная специализированная обработка чисел функционирует в любом случае.

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

int i;
bool bNum = int.TryParse(str, out i);

Логическое значение скажет вам, сработало ли это или нет.

Если вы хотите проверить, является ли строка числом (я предполагаю, что это строка, поскольку, если это число, да, вы знаете, что оно одно).

• Без регулярных выражений и
• максимально используя код Microsoft

Вы также можете сделать:

public static bool IsNumber(this string aNumber)
{
     BigInteger temp_big_int;
     var is_number = BigInteger.TryParse(aNumber, out temp_big_int);
     return is_number;
}

Об этом позаботятся обычные гадости

• Минус (-) или Плюс (+) в начале
• содержит десятичный символBigIntegers не будет анализировать числа с десятичными точками. (Итак: BigInteger.Parse("3.3")скину исключение, иTryParse за то же вернет false)
• нет смешных не цифр
• охватывает случаи, когда число превышает обычное использование Double.TryParse

Вам нужно будет добавить ссылку на ваш класс System.Numericsи иметь using System.Numerics;его (ну, во-вторых, бонус, я думаю, :)

Я думаю, что этот ответ будет просто потерян между всеми остальными, но в любом случае, здесь идет.

Я в конечном итоге по этому вопросу через Google , потому что я хотел , чтобы проверить , если stringбыло numericтак , что я мог бы просто использовать double.Parse("123")вместоTryParse() метода.

Почему? Потому что раздражает необходимость объявлять outпеременную и проверять результат, TryParse()прежде чем вы узнаете, был ли анализ неудачным или нет. Я хочу использовать, ternary operatorчтобы проверить, stringявляется лиnumerical , а затем просто разобрать его в первом тройном выражении или установить значение по умолчанию во втором выражении тройного.

Нравится:

var doubleValue = IsNumeric(numberAsString) ? double.Parse(numberAsString) : 0;

Это намного чище, чем:

var doubleValue = 0;
if (double.TryParse(numberAsString, out doubleValue)) {
    //whatever you want to do with doubleValue
}

Я сделал пару extension methodsдля этих случаев:

Метод расширения один

public static bool IsParseableAs<TInput>(this string value) {
    var type = typeof(TInput);

    var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder,
        new[] { typeof(string), type.MakeByRefType() }, null);
    if (tryParseMethod == null) return false;

    var arguments = new[] { value, Activator.CreateInstance(type) };
    return (bool) tryParseMethod.Invoke(null, arguments);
}

Пример:

"123".IsParseableAs<double>() ? double.Parse(sNumber) : 0;

Потому что IsParseableAs()пытается проанализировать строку как соответствующий тип вместо того, чтобы просто проверять, является ли строка «числовой», это должно быть довольно безопасно. И вы даже можете использовать его для нечисловых типов, которые имеют TryParse()метод, какDateTime .

Метод использует отражение, и в итоге вы вызываете TryParse()метод дважды, что, конечно, не так эффективно, но не все должно быть полностью оптимизировано, иногда удобство просто важнее.

Этот метод также можно использовать для простого разбора списка числовых строк в список doubleили другой тип со значением по умолчанию без необходимости перехвата каких-либо исключений:

var sNumbers = new[] {"10", "20", "30"};
var dValues = sNumbers.Select(s => s.IsParseableAs<double>() ? double.Parse(s) : 0);

Второй метод расширения

public static TOutput ParseAs<TOutput>(this string value, TOutput defaultValue) {
    var type = typeof(TOutput);

    var tryParseMethod = type.GetMethod("TryParse", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder,
        new[] { typeof(string), type.MakeByRefType() }, null);
    if (tryParseMethod == null) return defaultValue;

    var arguments = new object[] { value, null };
    return ((bool) tryParseMethod.Invoke(null, arguments)) ? (TOutput) arguments[1] : defaultValue;
}

Этот метод расширения позволяет вам анализировать stringкак любой, typeкоторый имеетTryParse() метод метод, а также позволяет указать значение по умолчанию, которое будет возвращаться в случае сбоя преобразования.

Это лучше, чем использовать троичный оператор с методом расширения, описанным выше, поскольку он выполняет преобразование только один раз. Это все еще использует отражение, хотя ...

Примеры:

"123".ParseAs<int>(10);
"abc".ParseAs<int>(25);
"123,78".ParseAs<double>(10);
"abc".ParseAs<double>(107.4);
"2014-10-28".ParseAs<DateTime>(DateTime.MinValue);
"monday".ParseAs<DateTime>(DateTime.MinValue);

Выходы:

123
25
123,78
107,4
28.10.2014 00:00:00
01.01.0001 00:00:00

Если вы хотите узнать, является ли строка числом, вы всегда можете попробовать ее проанализировать:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Обратите внимание, что TryParseвозвращается bool, который вы можете использовать, чтобы проверить, если ваш анализ успешно завершен.

Double.TryParse

bool Double.TryParse(string s, out double result)

ОБНОВЛЕНИЕ Кунала Ноэля Ответ

stringTest.All(char.IsDigit);
// This returns true if all characters of the string are digits.

Но для этого случая у нас есть пустые строки, которые пройдут этот тест, поэтому вы можете:

if (!string.IsNullOrEmpty(stringTest) && stringTest.All(char.IsDigit)){
   // Do your logic here
}

Лучшее гибкое решение со встроенной функцией .net под названием- char.IsDigit. Работает с неограниченными длинными номерами. Он вернет true, только если каждый символ представляет собой числовое число. Я использовал его много раз без проблем и с гораздо более простым решением, которое я когда-либо нашел. Я сделал пример метода. Он готов к использованию. Кроме того, я добавил валидацию для нулевого и пустого ввода. Таким образом, метод теперь полностью пуленепробиваемый

public static bool IsNumeric(string strNumber)
    {
        if (string.IsNullOrEmpty(strNumber))
        {
            return false;
        }
        else
        {
            int numberOfChar = strNumber.Count();
            if (numberOfChar > 0)
            {
                bool r = strNumber.All(char.IsDigit);
                return r;
            }
            else
            {
                return false;
            }
        }
    }

С помощью c # 7 вы можете встроить переменную out:

if(int.TryParse(str, out int v))
{
}

Используйте эти методы расширения, чтобы четко различать проверку, является ли строка числовой, и содержит ли строка только 0-9 цифр.

public static class ExtensionMethods
{
    /// <summary>
    /// Returns true if string could represent a valid number, including decimals and local culture symbols
    /// </summary>
    public static bool IsNumeric(this string s)
    {
        decimal d;
        return decimal.TryParse(s, System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.CurrentCulture, out d);
    }

    /// <summary>
    /// Returns true only if string is wholy comprised of numerical digits
    /// </summary>
    public static bool IsNumbersOnly(this string s)
    {
        if (s == null || s == string.Empty)
            return false;

        foreach (char c in s)
        {
            if (c < '0' || c > '9') // Avoid using .IsDigit or .IsNumeric as they will return true for other characters
                return false;
        }

        return true;
    }
}

public static bool IsNumeric(this string input)
{
    int n;
    if (!string.IsNullOrEmpty(input)) //.Replace('.',null).Replace(',',null)
    {
        foreach (var i in input)
        {
            if (!int.TryParse(i.ToString(), out n))
            {
                return false;
            }

        }
        return true;
    }
    return false;
}

Надеюсь это поможет

string myString = "abc";
double num;
bool isNumber = double.TryParse(myString , out num);

if isNumber 
{
//string is number
}
else
{
//string is not a number
}

Вставьте ссылку на Visual Basic в свой проект и используйте его метод Information.IsNumeric, такой как показан ниже, и сможете захватывать числа с плавающей запятой, а также целые числа в отличие от ответа выше, который только перехватывает целые числа.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

    if (Information.IsNumeric(txt))
        Console.WriteLine ("Numeric");

IsNumeric("12.3"); // true
IsNumeric("1"); // true
IsNumeric("abc"); // false

Попробуйте reges ниже

new Regex(@"^\d{4}").IsMatch("6")    // false
new Regex(@"^\d{4}").IsMatch("68ab") // false
new Regex(@"^\d{4}").IsMatch("1111abcdefg") ```

Все ответы полезны. Но при поиске решения, в котором числовое значение составляет 12 цифр или более (в моем случае), во время отладки я нашел следующее решение полезным:

double tempInt = 0;
bool result = double.TryParse("Your_12_Digit_Or_more_StringValue", out tempInt);

Эта переменная результата даст вам истину или ложь.

Вот метод C #. Метод Int.TryParse (String, Int32)

//To my knowledge I did this in a simple way
static void Main(string[] args)
{
    string a, b;
    int f1, f2, x, y;
    Console.WriteLine("Enter two inputs");
    a = Convert.ToString(Console.ReadLine());
    b = Console.ReadLine();
    f1 = find(a);
    f2 = find(b);

    if (f1 == 0 && f2 == 0)
    {
        x = Convert.ToInt32(a);
        y = Convert.ToInt32(b);
        Console.WriteLine("Two inputs r number \n so that addition of these text box is= " + (x + y).ToString());
    }
    else
        Console.WriteLine("One or two inputs r string \n so that concatenation of these text box is = " + (a + b));
    Console.ReadKey();
}

static int find(string s)
{
    string s1 = "";
    int f;
    for (int i = 0; i < s.Length; i++)
       for (int j = 0; j <= 9; j++)
       {
           string c = j.ToString();
           if (c[0] == s[i])
           {
               s1 += c[0];
           }
       }

    if (s == s1)
        f = 0;
    else
        f = 1;

    return f;
}