I am programming a thing where I am asking a user to type in several ingridients, how much they want of it and what the kg/ml/liter/etc price is. So that I add all the cost values(after multiplying the cost per unit times the measure they want) later display for them the most cheap and expensive ones. This is done in Visual Studio and the language is in C#. So I am typing this:
static void Ingridiens()
{
string ingridiensen;
Console.Write("Vad för ingridiIngridiensens behöver du?\nIngridiens: ");
ingridiensen = Console.ReadLine();
listaformat.Add(ingridiensen);
PrisPerEnhetEtt(prisetPerEnhet);
}
Ignore the variable names since they are in swedish. What I want help in is to check whether the input of the user is letters or something else. If they are not letters like numbers or any other special characters I want to return an error. And I also want to check if they are typinh one letter or not. It is one letter I still wanna return an error. But if they both type in letters(i.e. at least 2 letters) than I want to move on to the next method which in my case is PrisPerEnhetEtt.
I am finding it hard to fix this. I tried a lot of stuff, if statements, switch statements but i seems i need to invoke boolean variables. I am not sure how to do it. I am quite new to programming.
Thanks for all the help! :D
Using foreach
You can parse the chars of the string and use char.IsLetter and char.IsNumber or char.IsDigit like that with or without extension methods:
static public class StringHelper
{
static public bool IsText(this string input)
{
foreach ( char c in input )
if ( c != ' ' && !char.IsLetter(c) )
return false;
return true;
}
static public bool IsNumber(this string input)
{
foreach ( char c in input )
if ( !char.IsNumber(c) )
return false;
return true;
}
}
Difference between Char.IsDigit() and Char.IsNumber() in C#
Using Linq
using System.Linq;
static public bool IsText(this string input)
{
return input.All(c => c == ' ' || char.IsLetter(c));
}
static public bool IsNumber(this string input)
{
return input.All(c => char.IsNumber(c));
}
Or:
static public bool IsText(this string input)
=> input.All(c => c == ' ' || char.IsLetter(c));
static public bool IsNumber(this string input)
=> input.All(char.IsNumber);
Linq can be as slow as it is faster than loops depending on the processing done on the nature and the complexity and the amount of data. But Linq provides simple, clean, small, maintainable, robust, and magical code once learned.
For vs. Linq - Performance vs. Future
Is a LINQ statement faster than a 'foreach' loop?
Is the LINQ version faster than the foreach one?
Usage
string ingridiensen;
Console.Write("Vad för ingridiIngridiensens behöver du?\nIngridiens: ");
ingridiensen = Console.ReadLine();
Console.WriteLine(ingridiensen.IsNumber());
Console.WriteLine(ingridiensen.IsText());
Remark
In fact we can write to check if integer or double:
return int.TryParse(input, out var _);
return double.TryParse(input, out var _);
Advanced conditions
You can adapt the test conditions and create as many methods to match your needs : lower or upper case, space or no space allowed, point, special chars, integers, decimals, and so on:
static public bool IsWhatYouNeed(this string input)
{
foreach ( char c in input )
if ( !match(c) )
return false;
return true;
void bool match(char c)
{
...
}
}
You can also use the char position if needed:
static public bool IsWhatYouNeed(this string input)
{
for ( int index = 0; index < input.Length; index++ )
if ( !match(input[index], index) )
return false;
return true;
void bool match(char c, int pos)
{
...
}
}
The code above is lousy but written to give you the idea if needed.
I have a TextBoxD1.Text and I want to convert it to an int to store it in a database.
How can I do this?
Try this:
int x = Int32.Parse(TextBoxD1.Text);
or better yet:
int x = 0;
Int32.TryParse(TextBoxD1.Text, out x);
Also, since Int32.TryParse returns a bool you can use its return value to make decisions about the results of the parsing attempt:
int x = 0;
if (Int32.TryParse(TextBoxD1.Text, out x))
{
// you know that the parsing attempt
// was successful
}
If you are curious, the difference between Parse and TryParse is best summed up like this:
The TryParse method is like the Parse
method, except the TryParse method
does not throw an exception if the
conversion fails. It eliminates the
need to use exception handling to test
for a FormatException in the event
that s is invalid and cannot be
successfully parsed. - MSDN
Convert.ToInt32( TextBoxD1.Text );
Use this if you feel confident that the contents of the text box is a valid int. A safer option is
int val = 0;
Int32.TryParse( TextBoxD1.Text, out val );
This will provide you with some default value you can use. Int32.TryParse also returns a Boolean value indicating whether it was able to parse or not, so you can even use it as the condition of an if statement.
if( Int32.TryParse( TextBoxD1.Text, out val ){
DoSomething(..);
} else {
HandleBadInput(..);
}
int.TryParse()
It won't throw if the text is not numeric.
int myInt = int.Parse(TextBoxD1.Text)
Another way would be:
bool isConvertible = false;
int myInt = 0;
isConvertible = int.TryParse(TextBoxD1.Text, out myInt);
The difference between the two is that the first one would throw an exception if the value in your textbox can't be converted, whereas the second one would just return false.
Be careful when using Convert.ToInt32() on a char!
It will return the UTF-16 code of the character!
If you access the string only in a certain position using the [i] indexing operator, it will return a char and not a string!
String input = "123678";
^
|
int indexOfSeven = 4;
int x = Convert.ToInt32(input[indexOfSeven]); // Returns 55
int x = Convert.ToInt32(input[indexOfSeven].toString()); // Returns 7
You need to parse the string, and you also need to ensure that it is truly in the format of an integer.
The easiest way is this:
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
}
int x = 0;
int.TryParse(TextBoxD1.Text, out x);
The TryParse statement returns a boolean representing whether the parse has succeeded or not. If it succeeded, the parsed value is stored into the second parameter.
See Int32.TryParse Method (String, Int32) for more detailed information.
Enjoy it...
int i = 0;
string s = "123";
i =int.Parse(s);
i = Convert.ToInt32(s);
While there are already many solutions here that describe int.Parse, there's something important missing in all the answers. Typically, the string representations of numeric values differ by culture. Elements of numeric strings such as currency symbols, group (or thousands) separators, and decimal separators all vary by culture.
If you want to create a robust way to parse a string to an integer, it's therefore important to take the culture information into account. If you don't, the current culture settings will be used. That might give a user a pretty nasty surprise -- or even worse, if you're parsing file formats. If you just want English parsing, it's best to simply make it explicit, by specifying the culture settings to use:
var culture = CultureInfo.GetCulture("en-US");
int result = 0;
if (int.TryParse(myString, NumberStyles.Integer, culture, out result))
{
// use result...
}
For more information, read up on CultureInfo, specifically NumberFormatInfo on MSDN.
int x = Int32.TryParse(TextBoxD1.Text, out x) ? x : 0;
You can write your own extension method
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();
}
}
And wherever in code just call
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 this concrete case
int yourValue = TextBoxD1.Text.ParseInt();
As explained in the TryParse documentation, TryParse() returns a Boolean which indicates that a valid number was found:
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
}
You can convert string to int many different type methods in C#
First one is mostly use :
string test = "123";
int x = Convert.ToInt16(test);
if int value is higher you should use int32 type.
Second one:
int x = int.Parse(text);
if you want to error check, you can use TryParse method. In below I add nullable type;
int i=0;
Int32.TryParse(text, out i) ? i : (int?)null);
Enjoy your codes....
Conversion of string to int can be done for: int, Int32, Int64 and other data types reflecting integer data types in .NET
Below example shows this conversion:
This shows (for info) data adapter element initialized to int value. The same can be done directly like,
int xxiiqVal = Int32.Parse(strNabcd);
Ex.
string strNii = "";
UsrDataAdapter.SelectCommand.Parameters["#Nii"].Value = Int32.Parse(strNii );
Link to see this demo.
int i = Convert.ToInt32(TextBoxD1.Text);
//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;
}
You can use either,
int i = Convert.ToInt32(TextBoxD1.Text);
or
int i = int.Parse(TextBoxD1.Text);
You can do like below without TryParse or inbuilt functions:
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;
}
You also may use an extension method, so it will be more readable (although everybody is already used to the regular Parse functions).
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);
}
}
And then you can call it that way:
If you are sure that your string is an integer, like "50".
int num = TextBoxD1.Text.ParseToInt32();
If you are not sure and want to prevent crashes.
int num;
if (TextBoxD1.Text.TryParseToInt32(out num))
{
//The parse was successful, the num has the parsed value.
}
To make it more dynamic, so you can parse it also to double, float, etc., you can make a generic extension.
You can convert a string to int in C# using:
Functions of convert class i.e. Convert.ToInt16(), Convert.ToInt32(), Convert.ToInt64() or by using Parse and TryParse Functions. Examples are given here.
This would do
string x = TextBoxD1.Text;
int xi = Convert.ToInt32(x);
Or you can use
int xi = Int32.Parse(x);
Refer Microsoft Developer Network for more information
You can convert string to an integer value with the help of parse method.
Eg:
int val = Int32.parse(stringToBeParsed);
int x = Int32.parse(1234);
In C# v.7 you could use an inline out parameter, without an additional variable declaration:
int.TryParse(TextBoxD1.Text, out int x);
The way I always do this is like this:
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.
}
}
}
This is how I would do it.
All the above answers are good but for information, we can use int.TryParse which is safe to convert string to int, for example
// TryParse returns true if the conversion succeeded
// and stores the result in j.
int j;
if (Int32.TryParse("-105", out j))
Console.WriteLine(j);
else
Console.WriteLine("String could not be parsed.");
// Output: -105
TryParse never throws an exception—even on invalid input and null. It is overall preferable to int.Parse in most program contexts.
Source: How to convert string to int in C#? (With Difference between Int.Parse and Int.TryParse)
In case you know the string is an integer do:
int value = int.Parse(TextBoxD1.Text);
In case you don't know the string is an integer do it safely with TryParse.
In C# 7.0 you can use inline variable declaration.
If parse successes - value = its parsed value.
If parse fails - value = 0.
Code:
if (int.TryParse(TextBoxD1.Text, out int value))
{
// Parse succeed
}
Drawback:
You cannot differentiate between a 0 value and a non parsed value.
Here is the version of doing it via an Extension Method that has an option to set the default value as well, if the converting fails. In fact, this is what I used to convert a string input to any convertible type:
using System;
using System.ComponentModel;
public static class StringExtensions
{
public static TOutput AsOrDefault<TOutput>(this string input, TOutput defaultValue = default)
where TOutput : IConvertible
{
TOutput output = defaultValue;
try
{
var converter = TypeDescriptor.GetConverter(typeof(TOutput));
if (converter != null)
{
output = (TOutput)converter.ConvertFromString(input);
}
}
catch { }
return output;
}
}
For my usage, I limited the output to be one of the convertible types: https://learn.microsoft.com/en-us/dotnet/api/system.iconvertible?view=net-5.0. I don't need crazy logics to convert a string to a class, for example.
To use it to convert a string to int:
using FluentAssertions;
using Xunit;
[Theory]
[InlineData("0", 0)]
[InlineData("1", 1)]
[InlineData("123", 123)]
[InlineData("-123", -123)]
public void ValidStringWithNoDefaultValue_ReturnsExpectedResult(string input, int expectedResult)
{
var result = input.AsOrDefault<int>();
result.Should().Be(expectedResult);
}
[Theory]
[InlineData("0", 999, 0)]
[InlineData("1", 999, 1)]
[InlineData("123", 999, 123)]
[InlineData("-123", -999, -123)]
public void ValidStringWithDefaultValue_ReturnsExpectedResult(string input, int defaultValue, int expectedResult)
{
var result = input.AsOrDefault(defaultValue);
result.Should().Be(expectedResult);
}
[Theory]
[InlineData("")]
[InlineData(" ")]
[InlineData("abc")]
public void InvalidStringWithNoDefaultValue_ReturnsIntegerDefault(string input)
{
var result = input.AsOrDefault<int>();
result.Should().Be(default(int));
}
[Theory]
[InlineData("", 0)]
[InlineData(" ", 1)]
[InlineData("abc", 234)]
public void InvalidStringWithDefaultValue_ReturnsDefaultValue(string input, int defaultValue)
{
var result = input.AsOrDefault(defaultValue);
result.Should().Be(defaultValue);
}
METHOD 1
int TheAnswer1 = 0;
bool Success = Int32.TryParse("42", out TheAnswer1);
if (!Success) {
Console.WriteLine("String not Convertable to an Integer");
}
METHOD 2
int TheAnswer2 = 0;
try {
TheAnswer2 = Int32.Parse("42");
}
catch {
Console.WriteLine("String not Convertable to an Integer");
}
METHOD 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");
}
You can try the following. It will work:
int x = Convert.ToInt32(TextBoxD1.Text);
The string value in the variable TextBoxD1.Text will be converted into Int32 and will be stored in x.
While I agree on using the TryParse method, a lot of people dislike the use of out parameter (myself included). With tuple support having been added to C#, an alternative is to create an extension method that will limit the number of times you use out to a single instance:
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);
}
}
(Source: C# how to convert a string to int)
This question already has answers here:
Identify if a string is a number
(26 answers)
Closed 6 years ago.
I am writing a small console application in C# and it requires two numeric parameters/arguments to be passed to it. I am checking for no params, more than 2 params, if two params. I am also converting those params if 2 returned to numeric for calculations I'm doing. One thing I'm not doing is verifying what's being passed is a number so assume program will crap out if I pass a letter. Is there a look routing I can just run to verify the params passed are in deed able to be numbers? I can handle the kick out from there but curious how you check if an argument CAN be a number or not.
Thanks.
JR
I would simplify this task as follows:
Create custom Convert method:
static double Convert(string s)
{
double result;
if (!double.TryParse(s, out result))
result = double.NaN;
return result;
}
Use it in Main:
static void Main(string[] args)
{
var doubles = args.Select(a => Convert(a)).ToArray();
var valid = doubles.All(a => !double.IsNaN(a));
}
Here's one way;
static void Main(string[] args)
{
foreach (var arg in args)
{
int asInt;
// Returns "true" if arg can be parsed as an int and false otherwise;
// If you want to allow doubles you can also try double.TryParse in a similar manner
if (int.TryParse(arg, out asInt))
{
// Handle
}
// Failed to parse argument as an int
else
{
throw new ArgumentException("arg not an int");
}
}
}
You could also use a Regex:
static void Main(string[] args)
{
// Make sure this can is either an int or a double
var regex = new Regex(#"^-?(([0-9]+)|([0-9]+\.[0-9]+(e[0-9]+)?))$");
foreach (var arg in args)
{
if (!regex.IsMatch(arg))
throw new ArgumentException("arg " + arg + " is not an int or double");
}
}
Note a few important features of this regex:
- The "#" literal symbol in front of the regex string
- The ^ and $ to mark the beginning and end of lines - i.e. the string must contain only a number or only a double
- This bans empty strings as well
Edit: I edited the Regex to optionally allow for something like "1.0e100" or "-123", which, as pointed out in the comments, are also perfectly valid ints and doubles. Also, as pointed out in the comments, it's probably better to use int.TryParse or double.TryParse rather than reinventing the wheel.
There's also Char.IsDigit which always feels cleaner to me than checking for a failed parsing attempt. If you care about micro-optimizing, char.IsDigit is probably faster than parsing an invalid string too.
Or, if negative numbers or non-whole numbers are your thing, you can use char.IsNumber
See: https://msdn.microsoft.com/en-us/library/7f0ddtxh(v=vs.110).aspx
public static void Main(string[] args)
{
for(int i = 0; i < args.Length; i++)
{
if(args[i].All((c) => char.IsDigit(c))
{
//It's a number.
}
}
}
I have a input field that is supposed to take numbers only.
How can I validate the string?
Would this be ok:
string s = "12345";
double num;
bool isNum = double.TryParse(s, out num);
Or does .Net have a solution for this?
Single one line answer. Does the job.
string s = "1234";
if (s.ToCharArray().All(x => Char.IsDigit(x)))
{
console.writeline("its numeric");
}
else
{
console.writeline("NOT numeric");
}
What you've done looks correct.
You could also create an extension method to make it easier:
public static bool IsNumeric(this object _obj)
{
if (_obj == null)
return false;
bool isNum;
double retNum;
isNum = Double.TryParse(Convert.ToString(_obj), System.Globalization.NumberStyles.Any, System.Globalization.NumberFormatInfo.InvariantInfo, out retNum);
return isNum;
}
So then you could do:
s.IsNumeric()
your solution is ok but you could create a method that does this job for you. Bear in mind it may not work for other countries because of the culture. What about something like the below?
public bool isNumeric(string val, System.Globalization.NumberStyles NumberStyle)
{
Double result;
return Double.TryParse(val,NumberStyle,
System.Globalization.CultureInfo.CurrentCulture,out result);
}
VB.NET has the IsNumeric function but what you have there is the way to do that in C#. To make it available app-wide just write an extension method on string
public static bool IsNumeric(this string input)
{
if (string.IsNullOrWhitespace(input))
return false;
double result;
return Double.TryParse(input, out result);
}
You can use Regular Expression Validators in ASP.NET to constrain the input.
Why don't you try to validate the input through the UI? I don't know if you're using asp.net, if so, the RegularExpressionValidator is normally a valid solution for this. (http://www.w3schools.com/aspnet/control_regularexpvalidator.asp). Hope this helps!
I am using Visual Studio 2010.I want to check whether a string is numeric or not.Is there any built in function to check this or do we need to write a custom code?
You could use the int.TryParse method. Example:
string s = ...
int result;
if (int.TryParse(s, out result))
{
// The string was a valid integer => use result here
}
else
{
// invalid integer
}
There are also the float.TryParse, double.TryParse and decimal.TryParse methods for other numeric types than integers.
But if this is for validation purposes you might also consider using the built-in Validation controls in ASP.NET. Here's an example.
You can do like...
string s = "sdf34";
Int32 a;
if (Int32.TryParse(s, out a))
{
// Value is numberic
}
else
{
//Not a valid number
}
You can use Int32.TryParse()
http://msdn.microsoft.com/en-us/library/f02979c7.aspx
Yes there is: int.TryParse(...) check the out bool param.
Have a look at this question:
What is the C# equivalent of NaN or IsNumeric?
You can use built in methods Int.Parse or Double.Parse methods. You can write the following function and call where ever necessary to check it.
public static bool IsNumber(String str)
{
try
{
Double.Parse(str);
return true;
}
catch (Exception)
{
return false;
}
}
The problem with all the Double/Int32/... TryParse(...) methods is that with a long enough numeric string, the method will return false;
For example:
var isValidNumber = int.TryParse("9999999999", out result);
Here, isValidNumber is false and result is 0, although the given string is numeric.
If you don't need to use the string as int, I would go with regular expressions validation on this one:
var isValidNumber = Regex.IsMatch(input, #"^\d+$")
This will only match integers. "123.45" for example, will fail.
If you need to check for floating point numbers:
var isValidNumber = Regex.IsMatch(input, #"^[0-9]+(\.[0-9]+)?$")
Note: try to create a single Regex object and send it to your int testing method for better performance.
Try this:
string Str = textBox1.Text.Trim();
double Num;
bool isNum = double.TryParse(Str, out Num);
if (isNum)
MessageBox.Show(Num.ToString());
else
`enter code here`MessageBox.Show("Invalid number");
Use IsNumeric() to check whether given string is numeric or not. It always return True for numeric value regardless whether it is Int or Double.
string val=...;
bool b1 = Microsoft.VisualBasic.Information.IsNumeric(val);
using System;
namespace ConsoleApplication1
{
class Test
{
public static void Main(String[] args)
{
bool check;
string testStr = "ABC";
string testNum = "123";
check = CheckNumeric(testStr);
Console.WriteLine(check);
check = CheckNumeric(testNum);
Console.WriteLine(check);
Console.ReadKey();
}
public static bool CheckNumeric(string input)
{
int outPut;
if (int.TryParse(input, out outPut))
return true;
else
return false;
}
}
}
This will work for you!!
Try This-->
String[] values = { "87878787878", "676767676767", "8786676767", "77878785565", "987867565659899698" };
if (Array.TrueForAll(values, value =>
{
Int64 s;
return Int64.TryParse(value, out s);
}
))
Console.WriteLine("All elements are integer.");
else
Console.WriteLine("Not all elements are integer.");