Ik heb een TextBoxD1.Texten ik wil deze converteren naar een intom deze in een database op te slaan.
Hoe kan ik dit doen?
Antwoord 1, autoriteit 100%
Probeer dit:
int x = Int32.Parse(TextBoxD1.Text);
of beter nog:
int x = 0;
Int32.TryParse(TextBoxD1.Text, out x);
Ook sinds Int32.TryParseretourneert een boolu kunt de retourwaarde gebruiken om beslissingen te nemen over de resultaten van de parseerpoging:
int x = 0;
if (Int32.TryParse(TextBoxD1.Text, out x))
{
// you know that the parsing attempt
// was successful
}
Als je nieuwsgierig bent, kan het verschil tussen Parseen TryParsehet beste als volgt worden samengevat:
De TryParse-methode lijkt op de Parse
methode, behalve de TryParse-methode
werpt geen uitzondering als de
conversie mislukt. Het elimineert de
moet exception handling gebruiken om te testen
voor een FormatException in het evenement
die s is ongeldig en kan niet zijn
succesvol geparseerd. – MSDN
Antwoord 2, autoriteit 5%
Convert.ToInt32( TextBoxD1.Text );
Gebruik dit als u zeker weet dat de inhoud van het tekstvak een geldige intis. Een veiligere optie is
int val = 0;
Int32.TryParse( TextBoxD1.Text, out val );
Dit geeft je een standaardwaarde die je kunt gebruiken. Int32.TryParseretourneert ook een Booleaanse waarde die aangeeft of het kon parseren of niet, dus je kunt het zelfs gebruiken als de voorwaarde van een if-instructie.
if( Int32.TryParse( TextBoxD1.Text, out val ){
DoSomething(..);
} else {
HandleBadInput(..);
}
Antwoord 3, autoriteit 3%
int.TryParse()
Er wordt niet gegooid als de tekst niet numeriek is.
Antwoord 4, autoriteit 2%
int myInt = int.Parse(TextBoxD1.Text)
Een andere manier zou zijn:
bool isConvertible = false;
int myInt = 0;
isConvertible = int.TryParse(TextBoxD1.Text, out myInt);
Het verschil tussen de twee is dat de eerste een uitzondering zou veroorzaken als de waarde in je tekstvak niet kan worden geconverteerd, terwijl de tweede gewoon false retourneert.
Antwoord 5
Je moet de tekenreeks ontleden en je moet er ook voor zorgen dat deze echt de indeling van een geheel getal heeft.
De gemakkelijkste manier is als volgt:
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
}
Antwoord 6
Wees voorzichtig bij het gebruik van Convert.ToInt32()op een char!
Het retourneert de UTF-16code van het teken!
Als u de tekenreeks alleen op een bepaalde positie opent met behulp van de indexeringsoperator [i], wordt een chargeretourneerd en geen string!
String input = "123678";
^
|
int indexOfSeven = 4;
int x = Convert.ToInt32(input[indexOfSeven]); // Returns 55
int x = Convert.ToInt32(input[indexOfSeven].toString()); // Returns 7
Antwoord 7
int x = 0;
int.TryParse(TextBoxD1.Text, out x);
De TryParse-instructie retourneert een boolean die aangeeft of het ontleden is gelukt of niet. Als het gelukt is, wordt de geparseerde waarde opgeslagen in de tweede parameter.
Zie Int32.TryParse-methode (String, Int32)voor meer gedetailleerde informatie.
Antwoord 8
Geniet ervan…
int i = 0;
string s = "123";
i =int.Parse(s);
i = Convert.ToInt32(s);
Antwoord 9
Hoewel er hier al veel oplossingen zijn die int.Parsebeschrijven, ontbreekt er iets belangrijks in alle antwoorden. Doorgaans verschillen de tekenreeksrepresentaties van numerieke waarden per cultuur. Elementen van numerieke tekenreeksen zoals valutasymbolen, scheidingstekens voor groepen (of duizendtallen) en scheidingstekens voor decimalen verschillen allemaal per cultuur.
Als je een robuuste manier wilt creëren om een string naar een geheel getal te ontleden, is het daarom belangrijk om rekening te houden met de cultuurinformatie. Als je dat niet doet, de huidige cultuurinstellingenworden gebruikt. Dat kan een gebruiker een behoorlijk onaangename verrassing geven – of erger nog, als je bestandsindelingen aan het ontleden bent. Als u alleen Engelse parsering wilt, kunt u dit het beste eenvoudig expliciet maken door de te gebruiken cultuurinstellingen op te geven:
var culture = CultureInfo.GetCulture("en-US");
int result = 0;
if (int.TryParse(myString, NumberStyles.Integer, culture, out result))
{
// use result...
}
Lees voor meer informatie over CultureInfo, met name NumberFormatInfoop MSDN.
Antwoord 10
U kunt uw eigen extensiemethode schrijven
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();
}
}
En waar dan ook in de code, bel gewoon
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 dit concrete geval
int yourValue = TextBoxD1.Text.ParseInt();
Antwoord 11
int x = Int32.TryParse(TextBoxD1.Text, out x) ? x : 0;
Antwoord 12
Zoals uitgelegd in de TryParse-documentatie, keert TryParse() terug een Booleaanse waarde die aangeeft dat er een geldig nummer is gevonden:
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
}
Antwoord 13
Je kunt ook een extensiemethodegebruiken, zodat deze beter leesbaar is (hoewel iedereen al gewend aan de reguliere Parse-functies).
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);
}
}
En dan kun je het zo noemen:
-
Als je zeker weet dat je string een geheel getal is, zoals “50”.
int num = TextBoxD1.Text.ParseToInt32(); -
Als je het niet zeker weet en crashes wilt voorkomen.
int num; if (TextBoxD1.Text.TryParseToInt32(out num)) { //The parse was successful, the num has the parsed value. }
Om het dynamischer te maken, zodat je het ook kunt ontleden om te verdubbelen, zweven, etc., kun je een generieke extensie maken.
Antwoord 14
//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;
}
Antwoord 15
U kunt beide gebruiken,
int i = Convert.ToInt32(TextBoxD1.Text);
of
int i = int.Parse(TextBoxD1.Text);
Antwoord 16
Je kunt een string naar int in C# converteren met:
Functies van de convert class dwz Convert.ToInt16(), Convert.ToInt32(), Convert.ToInt64()of door Parseen TryParseFuncties. Voorbeelden worden hiergegeven.
Antwoord 17
Dit zou voldoende zijn
string x = TextBoxD1.Text;
int xi = Convert.ToInt32(x);
Of je kunt gebruiken
int xi = Int32.Parse(x);
Raadpleeg Microsoft Developer Network voor meer informatie
Antwoord 18
Je kunt het hieronder doen zonder TryParse of ingebouwde functies:
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;
}
Antwoord 19
Je kunt in C# strings naar int converteren
De eerste is meestal gebruik:
string test = "123";
int x = Convert.ToInt16(test);
Als de int-waarde hoger is, moet u het type int32 gebruiken.
Tweede:
int x = int.Parse(text);
Als u fouten wilt controleren, kunt u de TryParse-methode gebruiken. Hieronder voeg ik nullable type toe;
int i=0;
Int32.TryParse(text, out i) ? i : (int?)null);
Geniet van je codes….
Antwoord 20
Conversie van stringnaar intkan worden gedaan voor: int, Int32, Int64en andere datatypes die integer datatypes weerspiegelen in .NET
Het onderstaande voorbeeld toont deze conversie:
Dit toont (ter info) het gegevensadapterelement dat is geïnitialiseerd op int-waarde. Hetzelfde kan direct worden gedaan, zoals,
int xxiiqVal = Int32.Parse(strNabcd);
Bijvoorbeeld
string strNii = "";
UsrDataAdapter.SelectCommand.Parameters["@Nii"].Value = Int32.Parse(strNii );
Antwoord 21
int i = Convert.ToInt32(TextBoxD1.Text);
Antwoord 22
Je kunt een string naar een geheel getal converteren met behulp van de parse-methode.
Bijvoorbeeld:
int val = Int32.parse(stringToBeParsed);
int x = Int32.parse(1234);
Antwoord 23
De manier waarop ik dit altijd doe is als volgt:
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' statement says if the string is not a number, display an error, else now you will have an integer.
}
}
}
Zo zou ik het doen.
Antwoord 24
In C# v.7 zou je een inline out parameter kunnen gebruiken, zonder een extra variabele declaratie:
int.TryParse(TextBoxD1.Text, out int x);
Antwoord 25
Als je weet dat de string een geheel getal is, doe dan:
int value = int.Parse(TextBoxD1.Text);
Als je niet weet dat de string een geheel getal is, doe het dan veilig met TryParse.
In C# 7.0kun je inline variabele declaratie.
- Als het ontleden succesvol is – waarde = de geparseerde waarde.
- Als parseren mislukt – waarde = 0.
Code:
if (int.TryParse(TextBoxD1.Text, out int value))
{
// Parse succeed
}
Nadeel:
U kunt geen onderscheid maken tussen een 0-waarde en een niet-geparseerde waarde.
Antwoord 26
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");
}
Antwoord 27
Deze code werkt voor mij in Visual Studio 2010:
int someValue = Convert.ToInt32(TextBoxD1.Text);
Antwoord 28
Je kunt het volgende proberen. Het zal werken:
int x = Convert.ToInt32(TextBoxD1.Text);
De tekenreekswaarde in de variabele TextBoxD1.Text wordt geconverteerd naar Int32 en opgeslagen in x.
Antwoord 29
Hoewel ik het eens ben met het gebruik van de TryParse-methode, houden veel mensen niet van het gebruik van de parameter out(inclusief ikzelf). Nu tuple-ondersteuning is toegevoegd aan C#, is een alternatief om een extensiemethode te maken die het aantal keren dat u outgebruikt, beperkt tot een enkele instantie:
public static class StringExtensions
{
public static (int result, bool canParse) TryParse(this string s)
{
int res;
var valid = int.TryParse(s, out res);
return (result: res, canParse: valid);
}
}
(Bron: C# hoe een tekenreeks naar int)
Antwoord 30
Als je op zoek bent naar de lange weg, maak dan gewoon je enige 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;
}