Визначте, чи є рядок числом

Якщо у мене є ці рядки:

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);

або якщо вам не потрібен номер, ви можете скасувати вихідний параметр

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

В вар s можуть бути замінені їх відповідними типами!

Це повернеться вірно, якщо 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

З параметри порівняння IsNumeric

_{(джерело: aspalliance.com )}

_{(джерело: aspalliance.com )}

Це, мабуть, найкращий варіант у C #.

Якщо ви хочете знати, чи рядок містить ціле число (ціле число):

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

Метод TryParse спробує перетворити рядок у число (ціле число), і якщо він буде успішним, він поверне істинне та розмістить відповідне число у myInt. Якщо він не може, він повертає помилкове значення.

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

Якщо ви бажаєте прийняти десяткові числа, у десятковому класі також є .TryParse(...)метод. У наведеному вище обговоренні замініть int на десятковий, і застосовуються ті самі принципи.

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

Приклад.

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

Тоді результат буде = Правда

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;
    }
}

Якщо ви хочете отримати більш широкий спектр чисел, à la PHP's_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"це досконале дійсне числове значення, але воно не впишеться в числовий тип .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)

Необов’язковий параметр "культура" може використовуватися майже однаково.

Він обмежений тим, що не в змозі перетворити занадто великі рядки, щоб вони містилися в подвійному, але це обмежена вимога, і я думаю, якщо ви працюєте з числами, більшими за це, вам, ймовірно, знадобиться додаткова спеціалізована обробка чисел функціонує все одно.

Ви можете використовувати 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для того ж поверне помилкове)
• ніяких смішних нецифрових
• охоплює випадки, коли кількість перевищує звичайне використання 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повернення a bool, яке ви можете використовувати, щоб перевірити, чи вдалося розібратися.

Подвійний.Примірний

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

ОНОВЛЕННЯ відповіді Kunal Noel

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. Він працює з необмеженими довгими числами. Він поверне справжній лише тоді, коли кожен символ є числовим числом. Я використовував це багато разів, без проблем і набагато легшого чистішого рішення, яке я коли-небудь знайшов. Я зробив приклад метод. Він готовий до використання. Крім того, я додав перевірку нульового та порожнього вводу. Таким чином, метод тепер повністю захищений від куль

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 ви можете вбудовувати змінну:

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

Спробуйте регрес нижче

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;
}