Wie kann ich String in Int konvertieren?

Convert.ToInt32( TextBoxD1.Text );

Verwenden Sie diese Option, wenn Sie sicher sind, dass der Inhalt des Textfelds eine gültige Ganzzahl ist. Eine sicherere Option ist

int val = 0;
Int32.TryParse( TextBoxD1.Text, out val );

Dadurch erhalten Sie einen Standardwert, den Sie verwenden können. Int32.TryParse gibt auch einen booleschen Wert zurück, der angibt, ob eine Analyse möglich war oder nicht, sodass Sie ihn sogar als Bedingung für eine if -Anweisung verwenden können.

if( Int32.TryParse( TextBoxD1.Text, out val ){
  DoSomething(..);
} else {
  HandleBadInput(..);
}

int.TryParse()

Es wird nicht geworfen, wenn der Text nicht numerisch ist.

int myInt = int.Parse(TextBoxD1.Text)

Ein anderer Weg wäre:

bool isConvertible = false;
int myInt = 0;

isConvertible = int.TryParse(TextBoxD1.Text, out myInt);

Der Unterschied zwischen den beiden besteht darin, dass der erste eine Ausnahme auslöst, wenn der Wert in Ihrem Textfeld nicht konvertiert werden kann, während der zweite einfach false zurückgibt.

Sie müssen die Zeichenfolge analysieren und sicherstellen, dass sie wirklich das Format einer Ganzzahl hat.

Der einfachste Weg ist dieser:

int parsedInt = 0;
if (int.TryParse(TextBoxD1.Text, out parsedInt))
{
   // Code for if the string was valid
}
else
{
   // Code for if the string was invalid
}

Geniesse es...

int i = 0;
string s = "123";
i =int.Parse(s);
i = Convert.ToInt32(s);

int x = 0;
int.TryParse(TextBoxD1.Text, out x);

Die TryParse-Anweisung gibt einen Booleschen Wert zurück, der angibt, ob die Analyse erfolgreich war oder nicht. Wenn dies erfolgreich war, wird der analysierte Wert im zweiten Parameter gespeichert.

Weitere Informationen finden Sie unter Int32.TryParse-Methode (String, Int32).

Seien Sie vorsichtig, wenn Sie Convert.ToInt32 () auf einem Zeichen verwenden!
Es wird der TF-16 Code des Zeichens zurückgegeben!

Wenn Sie mit dem Indexierungsoperator [i] nur an einer bestimmten Position auf die Zeichenfolge zugreifen, wird ein char und kein string zurückgegeben!

String input = "123678";

int x = Convert.ToInt32(input[4]);  // returns 55

int x = Convert.ToInt32(input[4].toString());  // returns 7

Während es hier bereits viele Lösungen gibt, die int.Parse beschreiben, fehlt in allen Antworten etwas Wichtiges. Typischerweise unterscheiden sich die Zeichenfolgendarstellungen von numerischen Werten je nach Kultur. Elemente von numerischen Zeichenfolgen wie Währungssymbole, Gruppentrennzeichen (oder Tausendertrennzeichen) und Dezimaltrennzeichen variieren je nach Kultur.

Wenn Sie eine robuste Methode zum Parsen einer Zeichenfolge in eine Ganzzahl erstellen möchten, müssen Sie daher die Kulturinformationen berücksichtigen. Wenn Sie dies nicht tun, wird aktuelle Kultureinstellungen verwendet. Das könnte einen Benutzer ziemlich böse überraschen - oder noch schlimmer, wenn Sie Dateiformate analysieren. Wenn Sie nur die englische Syntax analysieren möchten, ist es am besten, sie explizit anzugeben, indem Sie die zu verwendenden Kultureinstellungen angeben:

var culture = CultureInfo.GetCulture("en-US");
int result = 0;
if (int.TryParse(myString, NumberStyles.Integer, culture, out result))
{
    // use result...
}

Weitere Informationen finden Sie in CultureInfo, insbesondere unter NumberFormatInfo in MSDN.

Sie können Ihre eigene Erweiterungsmethode schreiben

public static class IntegerExtensions
{
    public static int ParseInt(this string value, int defaultValue = 0)
    {
        int parsedValue;
        if (int.TryParse(value, out parsedValue))
        {
            return parsedValue;
        }

        return defaultValue;
    }

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

        return value.ParseInt();
    }
}

nd wo auch immer im Code gerade aufgerufen wird

int myNumber = someString.ParseInt(); // returns value or 0
int age = someString.ParseInt(18); // with default value 18
int? userId = someString.ParseNullableInt(); // returns value or null

In diesem konkreten Fall

int yourValue = TextBoxD1.Text.ParseInt();

Wie in der TryParse-Dokumentation erläutert, gibt TryParse () einen Booleschen Wert zurück, der angibt, dass eine gültige Zahl gefunden wurde:

bool success = Int32.TryParse(TextBoxD1.Text, out val);

if (success)
{
// put val in database
}
else
{
// handle the case that the string doesn't contain a valid number
}

Sie können entweder verwenden,

int i = Convert.ToInt32(TextBoxD1.Text);

oder

int i =int.Parse(TextBoxD1.Text);

Sie können eine Zeichenfolge in C # in int konvertieren, indem Sie Folgendes verwenden:

Funktionen von convert class, d. H. Convert.ToInt16(), Convert.ToInt32(), Convert.ToInt64() oder mithilfe von Parse- und TryParse-Funktionen. Beispiele sind hier .

//May be quite some time ago but I just want throw in some line for any one who may still need it

int intValue;
string strValue = "2021";

try
{
    intValue = Convert.ToInt32(strValue);
}
catch
{
    //Default Value if conversion fails OR return specified error
    // Example 
    intValue = 2000;
}

int x = Int32.TryParse(TextBoxD1.Text, out x)?x:0;

Die Konvertierung von string in int kann durchgeführt werden für: int, Int32, Int64 und andere Datentypen, die Integer-Datentypen in .NET widerspiegeln

Das folgende Beispiel zeigt diese Konvertierung:

Dieses Datenadapterelement show (für Informationen) wurde auf den Wert int initialisiert. Das gleiche kann direkt gemacht werden,

int xxiiqVal = Int32.Parse(strNabcd);

Ex.

string strNii = "";
UsrDataAdapter.SelectCommand.Parameters["@Nii"].Value = Int32.Parse(strNii );

Link um diese Demo zu sehen .

Das würde reichen

string x=TextBoxD1.Text;
int xi=Convert.ToInt32(x);

Oder Sie können verwenden

int xi=Int32.Parse(x);

Weitere Informationen finden Sie unter Microsoft Developer Network

sie können wie folgt auf TryParse oder eingebaute Funktionen verzichten

static int convertToInt(string a)
{
    int x=0;
    for (int i = 0; i < a.Length; i++)
        {
            int temp=a[i] - '0';
            if (temp!=0)
            {
                x += temp * (int)Math.Pow(10, (a.Length - (i+1)));
            }              
        }
    return x ;
}

Sie können auch eine Erweiterungsmethode verwenden, um die Lesbarkeit zu verbessern (obwohl jeder bereits mit den regulären Parse-Funktionen vertraut ist).

public static class StringExtensions
{
    /// <summary>
    /// Converts a string to int.
    /// </summary>
    /// <param name="value">The string to convert.</param>
    /// <returns>The converted integer.</returns>
    public static int ParseToInt32(this string value)
    {
        return int.Parse(value);
    }

    /// <summary>
    /// Checks whether the value is integer.
    /// </summary>
    /// <param name="value">The string to check.</param>
    /// <param name="result">The out int parameter.</param>
    /// <returns>true if the value is an integer; otherwise, false.</returns>
    public static bool TryParseToInt32(this string value, out int result)
    {
        return int.TryParse(value, out result);
    }
}

Und dann kannst du es so nennen:

1. Wenn Sie sicher sind, dass Ihre Zeichenfolge eine Ganzzahl ist, z. B. "50".

   int num = TextBoxD1.Text.ParseToInt32();
   

2. Wenn Sie sich nicht sicher sind und Abstürze vermeiden möchten.

   int num;
   if (TextBoxD1.Text.TryParseToInt32(out num))
   {
       //The parse was successful, the num has the parsed value.
   }
   

Um es dynamischer zu machen, damit Sie es auch in double, float usw. analysieren können, können Sie eine generische Erweiterung erstellen.

so mache ich das immer

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace example_string_to_int
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            string a = textBox1.Text;
            // this turns the text in text box 1 into a string
            int b;
            if (!int.TryParse(a, out b))
            {
                MessageBox.Show("this is not a number");
            }
            else
            {
                textBox2.Text = a+" is a number" ;
            }
            // then this if statment says if the string not a number display an error elce now you will have an intager.
        }
    }
}

so würde ich es machen, ich hoffe das hilft. (:

Sie können Zeichenfolgen mithilfe der Analysemethode in Ganzzahlwerte konvertieren.

Z.B:

int val = Int32.parse(stringToBeParsed);
int x = Int32.parse(1234);

int i = Convert.ToInt32(TextBoxD1.Text);

Am einfachsten ist es, einen Erweiterungshelfer wie diesen zu verwenden:

public static class StrExtensions
{
  public static int ToInt(this string s, int defVal = 0) => int.TryParse(s, out var v) ? v : defVal;
  public static int? ToNullableInt(this string s, int? defVal = null) => int.TryParse(s, out var v) ? v : defVal;
}

Die Bedienung ist so einfach:

var x = "123".ToInt(); // 123
var y = "abc".ToInt(); // 0

string t = null;
var z = t.ToInt(-1); // -1
var w = "abc".ToNullableInt(); // null

Sie können dies versuchen, es wird funktionieren:

int x = Convert.ToInt32(TextBoxD1.Text);

Der Zeichenfolgenwert in der Variablen TextBoxD1.Text wird in Int32 konvertiert und in x gespeichert.

METHODE 1

int  TheAnswer1 = 0;
bool Success = Int32.TryParse("42", out TheAnswer1);
if (!Success) {
    Console.WriteLine("String not Convertable to an Integer");
}

METHODE 2

int TheAnswer2 = 0;
try {
    TheAnswer2 = Int32.Parse("42");
}
catch {
    Console.WriteLine("String not Convertable to an Integer");
}

METHODE 3

int TheAnswer3 = 0;
try {
    TheAnswer3 = Int32.Parse("42");
}
catch (FormatException) {
    Console.WriteLine("String not in the correct format for an Integer");
}
catch (ArgumentNullException) {
    Console.WriteLine("String is null");
}
catch (OverflowException) {
    Console.WriteLine("String represents a number less than"
                      + "MinValue or greater than MaxValue");
}

Wenn Sie auf der Suche nach einem langen Weg sind, erstellen Sie einfach eine Methode:

static int convertToInt(string a)
    {
        int x = 0;

        Char[] charArray = a.ToCharArray();
        int j = charArray.Length;

        for (int i = 0; i < charArray.Length; i++)
        {
            j--;
            int s = (int)Math.Pow(10, j);

            x += ((int)Char.GetNumericValue(charArray[i]) * s);
        }
        return x;
    }

Dieser Code funktioniert für mich in Visual Studio 2010:

int someValue = Convert.ToInt32(TextBoxD1.Text);