Casting using a decimal in C# - c#

private int FindNumber(string sPar)
{
// Get the last number
int len = sPar.Length;
string s = sPar.Substring(len-1);
return new (int)Decimal(s);
}
In this I am getting the error ; required . Can any ine help me on this.
Thank You!


Change your code to this:
private int FindNumber(string sPar)
{
int len = sPar.Length;
string s = sPar.Substring(len - 1);
return Convert.ToInt32(s);
}
Or, even shorter:
private int FindNumber(string sPar)
{
return Convert.ToInt32(sPar.Substring(sPar.Length - 1));
}


I'm not 100% what you are trying to do here, but if you want to get 4 as the result from the string "17894" i guess you want to write it like this with minimum number of changes:
private int FindNumber(string sPar) {
// Get the last number
int len = sPar.Length;
string s = sPar.Substring(len-1);
return int.Parse(s);
}
No reason to include a decimal and parse it to an int if you are only taking one char of the string anyway.
Note that this will give an exception if the last char of the string for any reason is not a number.


what is Decimal(s)? If you mean "parse as a decimal, then cast to int":
return (int)decimal.Parse(s);
If it is known to be an integer, just:
return int.Parse(s);
Actually, since you are only interested in the last digit, you could cheat:
private static int FindNumber(string sPar)
{
char c = sPar[sPar.Length - 1];
if (c >= '0' && c <= '9') return (int)(c - '0');
throw new FormatException();
}


Decimal(s) is not a valid call since Decimal is a type. Try Decimal.Parse(s) instead if you are certain that s is a valid decimal, stored as a string. If not, use Decimal.TryParse instead.
Please take into account different Culture related problems also, check out the overload that takes an IFormatProvider (I think, not sure about the exact name)


Do you just want to parse the digit from the last position in the string?
private int FindNumber(string sPar)
{
return int.Parse(sPar.Substring(sPar.Length - 1));
}
Note that this will fail if (a) the string is null, (b) the string is empty, or (c) the last character of the string isn't a digit. You should add some checking to your method if these situations are likely to be a problem.


The last line is completely wrong.
Your code takes the last char of a string(that i presume is always a number) and cast it to an int.
Do the following
try{
return Int32.Parse(s);
}
catch(Exception e)
{
// manage conversion exception here
}


I suppose you want to convert string to decimal as your code is not very clear.
you can use
Decimal d1;
if(Decimal.TryParse(sPar,out d1))
{
return d1
}
else
{
return 0;
}

Related

error "Cannot implicitly convert 'string' to 'int' [duplicate]

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)

Check if string is valid representation of hex number

I am total noob regarding regex.
My goal is to check whether a string is a valid representation of a hex number.
Currently my implementation (which I find really inefficient) is having a List with all hex digits (0-9, A-F) and checking whether my string contains characters not contained in given List.
I bet this can be easily done using regular expressions but I have no idea how to implement it.
private bool ISValidHEX(string s)
{
List<string> ToCheck = new List<string>();
for (int i = 0; i < 10; i++)
{
ToCheck.Add(i.ToString());
}
ToCheck.Add("A");
ToCheck.Add("B");
ToCheck.Add("C");
ToCheck.Add("D");
ToCheck.Add("E");
ToCheck.Add("F");
for (int i = 0; i < s.Length; i++)
{
if( !ToCheck.Contains(s.Substring(i,1)))
{
return false;
}
}
return true;
}

I would have thought that it's quickest to attempt to convert your string to an integral type and deal with any exception. Use code like this:
int num = Int32.Parse(s, System.Globalization.NumberStyles.HexNumber);
The resulting code is possibly easier to follow than a regular expression and is particularly useful if you need the parsed value (else you could use Int32.TryParse which is adequately documented in other answers).
(One of my favourite quotations is by Jamie Zawinski: "Some people, when confronted with a problem, think 'I know, I'll use regular expressions.' Now they have two problems.")

To simply check
Check if string is valid represantion of HEX number
you may use a method like:
int res = 0;
if(int.TryParse(val,
System.Globalization.NumberStyles.HexNumber,
System.Globalization.CultureInfo.InvariantCulture, out res)) {
//IT'S A VALID HEX
}
Pay attention on System.Globalization.CultureInfo.InvariantCulture parameter, change it according to your needs.

I recommend to use Int32.TryParse.
There is an overload that allow the Hex numbers conversion
int v;
string test = "FF";
if(Int32.TryParse(test, NumberStyles.HexNumber, CultureInfo.CurrentCulture, out v))
Console.WriteLine("Is HEX:" + v.ToString());
This is better than a simple Int32.Parse because, in the case that you have an invalid hex or the conversion overflows the Int32.MaxValue you don't get an exception but you could simply test the boolean return value.
Warning, the string cannot be prefixed with "0x" or "&H"

I tried Google search. I found lots of solutions. Here are two:
Validate Hex Color Code with Regular Expression
Regular Expression Hexadecimal Number Validation
Example
//use System.Text.RegularExpressions before using this function
public bool vldRegex(string strInput)
{
//create Regular Expression Match pattern object
Regex myRegex = new Regex("^[a-fA-F0-9]+$");
//boolean variable to hold the status
bool isValid = false;
if (string.IsNullOrEmpty(strInput))
{
isValid = false;
}
else
{
isValid = myRegex.IsMatch(strInput);
}
//return the results
return isValid;
}

^[0-9a-fA-F]+$ will match strings which are numbers and valid hex letters BUT this doesn't match the possible 0x at the front. I'm sure you can add that if needed.

If your hex string will have a maximum of 32 characters (e.g. usually GUIDs fit this bill), then you could PadLeft the string with zeros to ensure it has always 32 characters and then use the Guid.TryParse
public static bool IsHex(string hexString)
{
var isHex = false;
if ((hexString ?? string.Empty).Length == 0)
return false;
if (hexString.Length > 0 && hexString.Length <= 32)
{
hexString = hexString.PadLeft(32, '0');
Guid guid;
isHex = Guid.TryParse(hexString, out guid);
}
else
{
throw new NotImplementedException("Use some other way to check the hex string!");
}
return isHex;
}
Try it here:
https://dotnetfiddle.net/bLaCAT

VB6 to C#: Loop or Index Issue?

I have an old VB6 project that I am converting to C#. I have a string. I am verifying, 1 character at a time, that it only contains [E0-9.+-].
This is the old VB6 code:
sepIndex = 1
Do While Mid(xyString, sepIndex, 1) Like "[E0-9.+-]"
sepIndex = sepIndex + 1
Loop
I am then using the index number to calculate the Left of the same string, and convert it to a double. Using Right, I then cut the string down to the remaining part of the string that I want:
xFinal = CDbl(left(xyString, sepIndex - 1))
xyString = LTrim(right(xyString, Len(xyString) - sepIndex + 1))
This works great in VB, and I have no problems whatsoever. In C# it is different. Knowing that the only way to emulate Left/Mid/Right in C# is to create my own function, I did so (part of my Utils namespace):
public static string Mid(string param, int startIndex)
{
try
{
//start at the specified index and return all characters after it
//and assign it to a variable
string result = param.Substring(startIndex);
//return the result of the operation
return result;
}
catch
{
return string.Empty;
}
}
public static string Right(string param, int length)
{
try
{
//start at the index based on the lenght of the sting minus
//the specified lenght and assign it a variable
string result = param.Substring(param.Length - length, length);
//return the result of the operation
return result;
}
catch
{
return string.Empty;
}
}
public static string Left(string param, int length)
{
try
{
//we start at 0 since we want to get the characters starting from the
//left and with the specified lenght and assign it to a variable
string result = param.Substring(0, length);
//return the result of the operation
return result;
}
catch
{
return string.Empty;
}
}
To the best of my knowledge, I have converted the code from VB6 to C#. The problem is that when it finally sets xyString, it is cutting the string in the wrong spot, and still leaving a trailing character that I want in xFinal.
From what I gather, this may be either an index issue (which I know in C#, Substring is 0-based, so I changed sepIndex to the value of 0), or problem with the wrong loop structure.
Here is the converted code, and I hope I could get some idea of what is going on here:
sepIndex = 0;
while (Regex.IsMatch(Utils.Mid(xyString, sepIndex, 1), "[E0-9.+-]"))
{
sepIndex++;
}
xFinal = Convert.ToDouble(Utils.Left(xyString, sepIndex - 1)); // - 1
xyString = Utils.Right(xyString, xyString.Length - sepIndex + 1).TrimStart(' '); // + 1
EDIT
This has been solved. I simply removed the +1 and -1 from my Utils.Left function, and it returned the proper string. Thanks for the inputs.

Seems to be just RegEx math with negative condition - "[^E0-9.+-]":
var sepIndex = Regex.Match(xyString, #"[^E0-9\.+-]+").Index;
If you need to do it by hand the easiest way to get single character is to just get single character from the string without trimming:
// replace Utils.Mid(xyString, sepIndex, 1) with
xyString[sepIndex]

Try using following
do{
sepIndex++;
}while (Regex.IsMatch(Utils.Mid(xyString, sepIndex, 1), "[E0-9.+-]"))

why not importing microsoft.visualbasic namespace?
class Program
{
static void Main(string[] args)
{
string t = Microsoft.VisualBasic.Strings.Mid("hello", 2);
}
}
you can reuse what you had before

converting double/floating to integer in C#

My question might looks like silly, but i struck with it.
I have a string value "155.300" and i want to convert it to integer.
I tryed but throwing System.FormatException....pls someone help me out.

Since your source data is string you need to Convert it to Double first then just cast it to int or use Convert.ToInt32, but remember Convert.ToInt32 rounds it to nearest integer number, whereas casting takes the int part of the number (truncate)
double d = Convert.ToDouble("155.00");
int a = (int) d;
int b = Convert.ToInt32(d);
Or in a single Line
int b =(int) Convert.ToDouble("155.000");
EDIT
Since you want to use decimal point as thousand separator, I believe in German culture you can try the following.
int b = ((int)Convert.ToDouble("154.500", new CultureInfo("de-DE")));
That will give you 154500
EDIT 2
Or much better is to use int.Parse with NumberStyles.AllowThousands:
int b = int.Parse("154.500", NumberStyles.AllowThousands, new CultureInfo("de-DE"));

First parse it as a decimal or double (probably best to use decimal as you've got decimal data) then either cast or use something like Math.Round, depending on your requirements.
Basically, you need to always consider what data you've got: "155.300" isn't a string representation of an integer, so don't try to parse it as an integer. Parse it as what it is, then convert that to an integer.
Alternatively, you could hack at the string representation first, but personally I find that to be a more brittle approach in many cases.
EDIT: Note that if this is really already an integer, but with a thousands separator, you don't need to use double at all - you can use int.Parse, specifying an appropriate culture and number style:
int parsed = int.Parse(text, NumberStyles.Integer | NumberStyles.AllowThousands,
culture);

Here is a working conversion sample. Take a special look with the edge conditions, the output may be different if using several rounding/casting techniques
class Program
{
public static int MyToInt(string str)
{
double result;
bool success = Double.TryParse(str, out result);
if (!success)
{
throw new ArgumentException(
"Cannot parse a string into a double");
}
return Convert.ToInt32(result); // 156
//return (int)result; // 155 <<
//return (int)Math.Round(result); // 156
}
static void Main(string[] args)
{
string s = "155.500";
int value = MyToInt(s);
}
}

You can try this:
string str = "123.123";
str = str.Remove(str.IndexOf('.'), 1);
int result;
int.TryParse(str, out result);
Edit: Based on your comment, modified to multiply by thousand.
Or you can just try:
string str = "123.123";
double result;
double.TryParse(str, out result);
int final = (int)(result * 1000);

check for valid number input - console application

I have a little problem with a simple console application in which i would like to detect if the user inputs a correctly formatted numerical value.
That is, values such as 1212sss or anything like asjkq12323 or a single character is not accepted. I would like to only accept pure integer values.
Here is what i have tried
bool detectNumber(string s)
{
int value=0;
Int.TryParse(s,out value);
return (value!=0)?true:false;
}
I appreciate any help. Thank you soooo much,,,,,

TryParse returns a boolean. Check that, not the value passed via the out parameter.
if( int.TryParse( s, out value ) )
{
// do something
}
Or just:
return int.TryParse( s, out value );
Incidentally, it is not necessary to initialize a value passed using the out keyword. The method declaring the parameter must initialize it before returning.
int foo; // legal
int.TryParse( "123", out foo );
All BCL "Try" methods follow the same convention (such as double.TryParse() for floating point numbers, as #gdoron mentioned in the comments).
And for the curious, source code for the underlying library which implements int.TryParse().

int value = 0;
bool ok = int.TryParse(s, out value);
return ok;

string line = Console.ReadLine();
int value;
if (int.TryParse(line, out value))
{
Console.WriteLine("Integer here!");
}
else
{
Console.WriteLine("Not an integer!");
}

There are several ways to test for only numeric numbers:
first of all, never use Int because of it's maximum value, either use int or Int32.
Parse
int result;
if (int.TryParse("123", out result))
{
Debug.WriteLine("Valid integer: " + result);
}
else
{
Debug.WriteLine("Not a valid integer");
}
Convert.ToInt32()
// throws ArgumentNullExceptionint
result1 = Int32.Parse(null);
// doesn't throw an exception, returns 0
int result2 = Convert.ToInt32(null);
IsNumeric()
using Microsoft.VisualBasic;
// ......
bool result = Information.IsNumeric("123");
Pattern Matching
string strToTest = "123";
Regex reNum = new Regex(#"^\d+$");
bool isNumeric = reNum.Match(strToTest).Success;

Your code works normal, you can only refactor it a bit. Following code is shorter but does exactly the same:
static bool IsInt32(string s)
{
int value;
return Int32.TryParse(s, out value);
}

Categories

Resources