Bir dizenin sayı olup olmadığını belirleme

Bu dizeleri varsa:

1. "abc" = false

2. "123" = true

3. "ab2" = false

IsNumeric()Bir dizenin geçerli bir sayı olup olmadığını belirleyebilen bir komut veya benzeri bir şey var mı?

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

C # 7'den itibaren güncelleme :

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

veya numaraya ihtiyacınız yoksa out parametresini atabilirsiniz

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

Var ler kendi türlerine göre değiştirilebilir!

Bu input, tüm sayılarsa true değerini döndürür . Bundan daha iyi olup olmadığını bilmiyorum TryParse, ama işe yarayacak.

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

Karakterlerle karıştırılmış bir veya daha fazla sayı olup olmadığını bilmek istiyorsanız, ^ +ve işaretlerini bırakın $.

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

Düzenleme: Aslında çok uzun bir dize potansiyel olarak TryParse taşabilir çünkü TryParse daha iyi olduğunu düşünüyorum.

Ayrıca kullanabilirsiniz:

stringTest.All(char.IsDigit);

trueTüm Sayısal Rakamlar (değil float) ve falsegiriş dizesi herhangi bir alfasayısal ise geri döner .

Lütfen dikkat : stringTestboş bir dize olmamalıdır, çünkü bu sayısal olma testini geçecektir.

Bu işlevi birkaç kez kullandım:

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

Ancak kullanabilirsiniz;

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

Gönderen Kıyaslama vererek isNumeric öğesinin Seçenekler

_{(kaynak: aspalliance.com )}

_{(kaynak: aspalliance.com )}

Bu muhtemelen C # en iyi seçenektir.

Dizenin bir tam sayı (tamsayı) içerip içermediğini bilmek istiyorsanız:

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

TryParse yöntemi, dizeyi bir sayıya (tamsayı) dönüştürmeyi dener ve başarılı olursa true değerini döndürür ve karşılık gelen sayıyı myInt öğesine yerleştirir. Eğer yapamazsa, yanlış döndürür.

int.Parse(someString)Diğer yanıtlarda gösterilen alternatifi kullanan çözümler işe yarar, ancak çok daha yavaştır, çünkü istisnaları atmak çok pahalıdır. TryParse(...)sürüm 2'de C # diline eklendi ve o zamana kadar seçeneğiniz yoktu. Şimdi yapıyorsunuz: bu nedenle Parse()alternatiften kaçınmalısınız .

Ondalık sayıları kabul etmek istiyorsanız, ondalık sınıfın da bir .TryParse(...)yöntemi vardır. Yukarıdaki tartışmada int'i ondalık ile değiştirin ve aynı ilkeler geçerlidir.

Söz konusu dizenin geçip geçmeyeceğini görmek için birçok veri türü için yerleşik TryParse yöntemlerini her zaman kullanabilirsiniz.

Misal.

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

Sonuç = Doğru olur

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

Sonuç = yanlış

İnt.Parse veya double.Parse'ı kullanmak istemiyorsanız, kendinize böyle bir şeyle yuvarlayabilirsiniz:

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

Daha geniş bir sayı yelpazesini (à la PHP'nin is_numeric) yakalamak istiyorsanız , aşağıdakileri kullanabilirsiniz:

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

Ünite testi:

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

Bir değerin sayısal olması, bunun sayısal bir türe dönüştürülebileceği anlamına gelmediğini unutmayın. Örneğin, "999999999999999999999999999999.9999999999"geçerli bir sayısal değerdir, ancak .NET sayısal türüne sığmaz (standart kitaplıkta tanımlanan bir değer değildir).

Bu eski bir iplik olduğunu biliyorum, ama cevapların hiçbiri gerçekten benim için yaptım - ya verimsiz, ya da kolay yeniden kullanım için kapsüllenmiş değil. Ben de dize boş veya boş olsaydı yanlış döndüğünden emin olmak istedim. TryParse bu durumda true değerini döndürür (boş bir dize, sayı olarak ayrıştırılırken hataya neden olmaz). İşte, benim dize uzantısı yöntemi:

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

Kullanımı kolay:

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

Veya, diğer sayı türlerini test etmek istiyorsanız, 'stili' belirleyebilirsiniz. Bir sayıyı Üs ile dönüştürmek için şunları kullanabilirsiniz:

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

Veya olası bir Hex dizesini test etmek için şunları kullanabilirsiniz:

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

İsteğe bağlı 'kültür' parametresi de aynı şekilde kullanılabilir.

Bir çiftte yer almak için çok büyük olan dizeleri dönüştürememekle sınırlıdır, ancak bu sınırlı bir gereksinimdir ve bence bundan daha büyük sayılarla çalışıyorsanız, muhtemelen ek özel numara işlemeye ihtiyacınız olacak zaten çalışır.

Dizenin bir tamsayıya ayrıştırılıp ayrıştırılamayacağını belirlemek için TryParse kullanabilirsiniz.

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

Boole size işe yarayıp yaramadığını söyleyecektir.

Eğer bir dize bir sayı olup olmadığını kontrol etmek istiyorsanız (bir sayı olduğu için bir dize olduğunu varsayıyorum, duh, bir olduğunu biliyorsunuz).

• Normal ifade olmadan ve
• Microsoft'un kodunu mümkün olduğunca kullanmak

ayrıca şunları da yapabilirsiniz:

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

Bu olağan nasties ile ilgilenecektir:

• Başlangıçta eksi (-) veya Artı (+)
• ondalık karakter içeriyorBigIntegers ondalık noktalı sayıları ayrıştırmaz. (Yani: BigInteger.Parse("3.3")bir istisna atacak ve TryParseaynı için yanlış dönecektir)
• komik rakamlar yok
• sayının normal kullanımından daha büyük olduğu durumları kapsar Double.TryParse

Sınıfınıza bir referans eklemeniz System.Numericsve using System.Numerics;sınıfınızın üstünde olmanız gerekir (ikincisi sanırım bir bonus :)

Sanırım bu cevap diğer tüm cevaplar arasında kaybolacak, ama her neyse, işte gidiyor.

Ben kontrol etmek istedim çünkü Google üzerinden bu soruya sona erdi stringoldu numericSadece kullanabilir böylece double.Parse("123")yerine TryParse()yöntemle.

Neden? Bir outdeğişken bildirmek TryParse()ve ayrıştırmanın başarısız olup olmadığını bilmeden önce sonucunu kontrol etmek can sıkıcıdır . Kullanmak istediğim ternary operatorolmadığını kontrol etmek stringolduğunu numericalve sonra sadece ilk üçlü ifadede ayrıştırmak veya ikinci üçlü ifadesinde varsayılan bir değer sağlar.

Bunun gibi:

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

Şundan çok daha temiz:

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

extension methodsBu davalar için bir çift yaptım :

Birinci uzantı yöntemi

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

Misal:

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

Çünkü IsParseableAs()çalışır sadece dize ise kontrol yerine uygun türü olarak dize ayrıştırmak için "sayısal" oldukça güvenli olmalıdır. Hatta bir TryParse()yöntemi olan sayısal olmayan türler için bile kullanabilirsiniz DateTime.

Yöntem yansıma kullanır ve TryParse()yöntemi iki kez çağırırsınız, ki bu elbette etkili değildir, ancak her şey tam olarak optimize edilmemelidir, bazen kolaylık daha da önemlidir.

Bu yöntem, sayısal dizelerin bir listesini doubleherhangi bir istisna yakalamak zorunda kalmadan varsayılan değere sahip bir listeye veya başka bir türe kolayca ayrıştırmak için de kullanılabilir :

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

Genişletme yöntemi iki

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

Bu uzantı yöntemi , bir yöntemi olan stringherhangi typebir TryParse()yöntemi ayrıştırmanıza ve ayrıca dönüşüm başarısız olursa döndürülecek varsayılan bir değer belirtmenize olanak tanır.

Bu, üçlü operatörü yukarıdaki uzantı yöntemiyle kullanmaktan daha iyidir, çünkü dönüşümü yalnızca bir kez yapar. Yine de yansıma kullanıyor ...

Örnekler:

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

Çıktılar:

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

Bir dizenin sayı olup olmadığını bilmek istiyorsanız, onu her zaman ayrıştırmayı deneyebilirsiniz:

var numberString = "123";
int number;

int.TryParse(numberString , out number);

Ayrıştırma işleminizin başarılı olup olmadığını kontrol etmek için kullanabileceğiniz TryParsebir a döndürdüğünü unutmayın bool.

Double.TryParse

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

Kunal Noel GÜNCELLEME Cevap

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

Ancak, bu durumda, boş dizelerin bu testi geçeceğini var, böylece şunları yapabilirsiniz:

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

Denilen .net yerleşik işleviyle en iyi esnek çözüm char.IsDigit. Sınırsız uzun sayılarla çalışır. Yalnızca her karakter sayısal bir sayı olduğunda true değerini döndürür. Ben hiçbir sorun ve şimdiye kadar buldum çok daha kolay bir çözüm ile birçok kez kullandım. Örnek bir yöntem yaptım, kullanıma hazır. Ayrıca boş ve boş girdi için doğrulama ekledim. Bu yüzden yöntem artık tamamen kurşun geçirmez

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 ile out değişkenini satır içi yapabilirsiniz:

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

Dizenin sayısal olup olmadığını ve dizenin yalnızca 0-9 basamak içerip içermediğini kontrol etmek için bu uzantı yöntemlerini kullanın

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

Bu yardımcı olur umarım

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

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

Projenizde Visual Basic'e bir başvuru çekin ve aşağıda gösterildiği gibi onun Information.IsNumeric yöntemini kullanın ve sadece ints yakalayan yukarıdaki yanıtın aksine şamandıraları ve tam sayıları yakalayabilir.

    // Using Microsoft.VisualBasic;

    var txt = "ABCDEFG";

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

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

Aşağıdaki tabloları deneyin

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

Tüm Cevaplar Yararlıdır. Ancak Sayısal değerin 12 basamak veya daha fazla olduğu bir çözüm ararken (benim durumumda), daha sonra hata ayıklama sırasında aşağıdaki çözümü yararlı buldum:

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

Sonuç değişkeni size doğru veya yanlış verir.

İşte C # yöntemi. Int.TryParse Yöntemi (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;
}