I am trying to use TryParse to find if the string value is an integer. If the value is an integer then skip foreach loop. Here is my code.
string strValue = "42 "
if (int.TryParse(trim(strValue) , intVal)) == false
{
break;
}
intVal is a variable of type int?(nullable INT). How can I use Tryparse with nullable int?
Here's an option for a nullable int with TryParse
public int? TryParseNullable(string val)
{
int outValue;
return int.TryParse(val, out outValue) ? (int?)outValue : null;
}
int? myVal = int.TryParse(toCheck, out int tmp) ? (int?)tmp : null;
You can't do this without using another variable, unfortunately - because the type of out arguments has to match the parameter exactly.
Like Daniel's code, but fixed in terms of the second argument, trimming, and avoiding comparisons with Boolean constants:
int tmp;
if (!int.TryParse(strValue.Trim(), out tmp))
{
break;
}
intVal = tmp;
strValue could be null or not. If it's coming from a text box, it probably can't be null. My code doesn't try to address this, but we really don't know whether or not it should address it.
if? e.g: if (int.TryParse(Request["idParent"], out tmp)) idParent = tmp; (otherwise its null)
null in the case that strValue can't be parsed as an int. Of course, you should never copy/paste from the internet just because an answer is accepted ^_^.int? myVal = int.TryParse(toCheck, out int tmp) ? (int?)tmp : null;Could not prevent myself to produce a generic version. Usage below.
public class NullableHelper
{
public delegate bool TryDelegate<T>(string s, out T result);
public static bool TryParseNullable<T>(string s, out T? result, TryDelegate<T> tryDelegate) where T : struct
{
if (s == null)
{
result = null;
return true;
}
T temp;
bool success = tryDelegate(s, out temp);
result = temp;
return success;
}
public static T? ParseNullable<T>(string s, TryDelegate<T> tryDelegate) where T : struct
{
if (s == null)
{
return null;
}
T temp;
return tryDelegate(s, out temp)
? (T?)temp
: null;
}
}
bool? answer = NullableHelper.ParseNullable<bool>(answerAsString, Boolean.TryParse);
You can create a helper method to parse a nullable value.
Example Usage:
int? intVal;
if( !NullableInt.TryParse( "42", out intVal ) )
{
break;
}
Helper Method:
public static class NullableInt
{
public static bool TryParse( string text, out int? outValue )
{
int parsedValue;
bool success = int.TryParse( text, out parsedValue );
outValue = success ? (int?)parsedValue : null;
return success;
}
}
You could also make an extension method for this purpose;
public static bool TryParse(this object value, out int? parsed)
{
parsed = null;
try
{
if (value == null)
return true;
int parsedValue;
parsed = int.TryParse(value.ToString(), out parsedValue) ? (int?)parsedValue : null;
return true;
}
catch (Exception)
{
return false;
}
}
I've made this an extension on the object type, but it could equally well be on string. Personally I like these parser-extensions to be available on any object hence the extension on object instead of string.
Example of use:
[TestCase("1", 1)]
[TestCase("0", 0)]
[TestCase("-1", -1)]
[TestCase("2147483647", int.MaxValue)]
[TestCase("2147483648", null)]
[TestCase("-2147483648", int.MinValue)]
[TestCase("-2147483649", null)]
[TestCase("1.2", null)]
[TestCase("1 1", null)]
[TestCase("", null)]
[TestCase(null, null)]
[TestCase("not an int value", null)]
public void Should_parse_input_as_nullable_int(object input, int? expectedResult)
{
int? parsedValue;
bool parsingWasSuccessfull = input.TryParse(out parsedValue);
Assert.That(parsingWasSuccessfull);
Assert.That(parsedValue, Is.EqualTo(expectedResult));
}
The downside would be that this breaks with the frameworks syntax for parsing values;
int.TryParse(input, out output))
But I like the shorter version of it (whether it's more readable or not might be subject to discussion);
input.TryParse(out output)
TryParse for int only. What about double? Or bool?
T is implicitly convertible to T? for structs. This is overkill.