c# - with - tryparse syntax




Como posso converter String para Int? (19)

A conversão de string para int pode ser feita para: int , Int32 , Int64 e outros tipos de dados refletindo tipos de dados inteiros no .NET

Abaixo, o exemplo mostra essa conversão:

Esse elemento do adaptador de dados de show (para informações) foi inicializado para o valor int. O mesmo pode ser feito diretamente,

int xxiiqVal = Int32.Parse(strNabcd);

Ex.

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

Link para ver esta demonstração .

Eu tenho um TextBoxD1.Text e quero convertê-lo para um int para armazená-lo em um banco de dados.

Como posso fazer isso?


A maneira mais simples é usar um auxiliar de extensão como este:

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

O uso é tão simples:

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

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

Conforme explicado na Int32.TryParse do Int32.TryParse , TryParse () retorna um booleano que indica que um número válido foi encontrado:

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
}

Embora já existam muitas soluções aqui que descrevem int.Parse , há algo importante em falta em todas as respostas. Normalmente, as representações de cadeia de valores numéricos diferem por cultura. Elementos de cadeias numéricas, como símbolos de moeda, separadores de grupo (ou milhares) e separadores decimais, todos variam de acordo com a cultura.

Se você quiser criar uma maneira robusta de analisar uma string para um inteiro, é importante levar em conta as informações da cultura. Se você não fizer isso, as configurações de cultura atuais serão usadas. Isso pode dar ao usuário uma surpresa desagradável - ou, pior ainda, se você estiver analisando formatos de arquivo. Se você quer apenas analisar o inglês, é melhor simplesmente explicitar, especificando as configurações de cultura a serem usadas:

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

Para mais informações, leia sobre CultureInfo, especificamente NumberFormatInfo no MSDN.



MÉTODO 1

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

MÉTODO 2

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

MÉTODO 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");
}

Tenha cuidado ao usar Convert.ToInt32 () em um char!
Ele retornará o código UTF-16 do personagem!

Se você acessar a string apenas em uma determinada posição usando o operador de indexação [i] , ele retornará um char e não uma string !

String input = "123678";

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

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

Tente isto:

int x = Int32.Parse(TextBoxD1.Text);

ou melhor ainda:

int x = 0;

Int32.TryParse(TextBoxD1.Text, out x);

Além disso, como Int32.TryParse retorna um bool você pode usar seu valor de retorno para tomar decisões sobre os resultados da tentativa de análise:

int x = 0;

if (Int32.TryParse(TextBoxD1.Text, out x))
{
    // you know that the parsing attempt
    // was successful
}

Se você está curioso, a diferença entre o Parse e o TryParse é resumida da seguinte forma:

O método TryParse é como o método Parse, exceto que o método TryParse não lança uma exceção se a conversão falhar. Ele elimina a necessidade de usar o tratamento de exceções para testar um FormatException no caso de s ser inválido e não poder ser analisado com êxito. - Int32.TryParse


Você pode converter uma string para int em C # usando:

Funções de convert classe ie Convert.ToInt16() , Convert.ToInt32() , Convert.ToInt64() ou usando Parse e TryParse Functions. Exemplos são dados here .


Você pode tentar isso, vai funcionar:

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

O valor da string na variável TextBoxD1.Text será convertido em Int32 e será armazenado em x.


Você também pode usar

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

ou

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

Você também pode usar um método de extensão , por isso será mais legível (embora todos já estejam acostumados com as funções regulares do Parse).

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

E então você pode chamar assim:

  1. Se você tem certeza de que sua string é um inteiro, como "50".

    int num = TextBoxD1.Text.ParseToInt32();
  2. Se você não tiver certeza e quiser evitar falhas.

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

Para torná-lo mais dinâmico, para que você possa analisá-lo também para duplicar, flutuar, etc., você pode criar uma extensão genérica.


isso pode te ajudar; D

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

        float Stukprijs;
        float Aantal;
        private void label2_Click(object sender, EventArgs e)
        {

        }

        private void button2_Click(object sender, EventArgs e)
        {
            MessageBox.Show("In de eersre textbox staat een geldbedrag." + Environment.NewLine + "In de tweede textbox staat een aantal." + Environment.NewLine + "Bereken wat er moetworden betaald." + Environment.NewLine + "Je krijgt 15% korting over het bedrag BOVEN de 100." + Environment.NewLine + "Als de korting meer dan 10 euri is," + Environment.NewLine + "wordt de korting textbox lichtgroen");
        }

        private void button1_Click(object sender, EventArgs e)
        {
            errorProvider1.Clear();
            errorProvider2.Clear();
            if (float.TryParse(textBox1.Text, out Stukprijs))
            {
                if (float.TryParse(textBox2.Text, out Aantal))
                {
                    float Totaal = Stukprijs * Aantal;
                    string Output = Totaal.ToString();
                    textBox3.Text = Output;
                    if (Totaal >= 100)
                    {
                        float korting = Totaal - 100;
                        float korting2 = korting / 100 * 15;
                        string Output2 = korting2.ToString();
                        textBox4.Text = Output2;
                        if (korting2 >= 10)
                        {
                            textBox4.BackColor = Color.LightGreen;
                        }
                        else
                        {
                            textBox4.BackColor = SystemColors.Control;
                        }
                    }
                    else
                    {
                        textBox4.Text = "0";
                        textBox4.BackColor = SystemColors.Control;
                    }
                }
                else
                {
                    errorProvider2.SetError(textBox2, "Aantal plz!");
                }

            }
            else
            {
                errorProvider1.SetError(textBox1, "Bedrag plz!");
                if (float.TryParse(textBox2.Text, out Aantal))
                {

                }
                else
                {
                    errorProvider2.SetError(textBox2, "Aantal plz!");
                }
            }

        }

        private void BTNwissel_Click(object sender, EventArgs e)
        {
            //LL, LU, LR, LD.
            Color c = LL.BackColor;
            LL.BackColor = LU.BackColor;
            LU.BackColor = LR.BackColor;
            LR.BackColor = LD.BackColor;
            LD.BackColor = c;
        }

        private void button3_Click(object sender, EventArgs e)
        {
            MessageBox.Show("zorg dat de kleuren linksom wisselen als je op de knop drukt.");
        }
    }
}

você pode fazer como abaixo sem TryParse ou funções embutidas

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

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

Convert.ToInt32( TextBoxD1.Text );

Use isso se você tiver certeza de que o conteúdo da caixa de texto é um int válido. Uma opção mais segura é

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

Isso fornecerá a você algum valor padrão que você pode usar. Int32.TryParse também retorna um valor booleano indicando se ele foi capaz de analisar ou não, assim você pode até usá-lo como a condição de uma instrução if .

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

int myInt = int.Parse(TextBoxD1.Text)

Outra maneira seria:

bool isConvertible = false;
int myInt = 0;

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

A diferença entre os dois é que o primeiro lançaria uma exceção se o valor em sua caixa de texto não puder ser convertido, enquanto o segundo retornaria false.


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

A instrução TryParse retorna um booleano que representa se a análise foi bem-sucedida ou não. Se tiver êxito, o valor analisado é armazenado no segundo parâmetro.

Veja Int32.TryParse para informações mais detalhadas.


int.TryParse()

Não será lançado se o texto não for numérico.







type-conversion