I saw in a blog that you can cast from string to int and something even better dealing with possible null values using (int?). See blog here
However, when I try to do it, visual studio complains saying Cannot implicitly convert type 'int' to 'string'.
Is it really possible? Or am I doing something wrong?
Use int.Parse() or, better yet, int.TryParse()
int someInt;
if(int.TryParse(aString, out someInt)
{
// work with the int
}
else
{
// handle error
}
The difference is, int.Parse() throws an exception if the string isn't a valid integer. int.TryParse() returns true and sets its out parameter to the result if it's a valid integer, otherwise it returns false and the out parameter's value is undefined.
The article discusses the null coalesce operator (??), not nullables (int?, bool? etc).
This is a mechanism to ensure the first non null value can be assigned to a variable.
From MSDN:
is used to define a default value for a nullable value types as well as reference types. It returns the left-hand operand if it is not null; otherwise it returns the right operand.
Both sides of the operator should be of the same type or have an implicit conversion between them in order to use it.
In the article mentioned an XElement is casted to an int (or int?), because XElement implements explicit conversion operators.
You cannot cast a string that way. You would have to use something like int.Parse or int.TryParse for that.
What you're trying to do can't be done. But, you can use extension method, so you'd end up using it like this:
int? myInt = "123".ToNullableInt();
The definition of the extension would be:
public static class Extensions
{
public static int? ToNullableInt(this string arg)
{
int result;
if (int.TryParse(arg, out result))
{
return result;
}
return null;
}
}
You can't cast from string to int, but you can do a conversion. So you might want to do this:
int value = Convert.ToInt32("1234");
The blog article you link to does not talk about casting string to int. Rather, it talks about using the null coalescing operator. One way this can be used to deal with converting strings, would be to make a convert method returning int?, then using null coalescing operator to provide the default value of choice. Then you would be able to say:
int value = SafeConvert.ToInt32(stringValue) ?? 1; // Assigned 1 if conversion fails.
This is one possible implementation of the SafeConvert.ToInt32 method:
public static int? ToInt32(string value)
{
int n;
if(!int.TryParse(value,out n))
return null;
return n;
}
Casting string to integer is not possible. However, int.Parse(string) and Convert.ToInt32(object) could help.
You can cast null values of any type (as long as its boxed) to Nullable... In this case you'll always get null.
Lets have a brief look at it with sample code
int x = int.parse("546")
will produce output
x = 546
but this
x = int.parse("546.0")
will give error. For this you have to do double
x = convert.todouble("546.0")
which will give
x = 546.0
and convert.toint32(x) will produce 546.
So crux is that string containing literal of double akin can't be directly converted to double primitive type.
Nowhere in that article did I see him cast a String as an int. If you know the string is an int, you can use Int32.Parse("123"), and if you aren't sure, you can use Int32.TryParse("123x",out intValue), which will return false if the string is not an int (as opposed to throwing an error)
Can't you just use the int.TryParse method?
string stringToCast = "1";
int result;
int.TryParse(stringToCast, out result);
Yuo should be able to cast using int.Parse or int.TryParse. If you're just doing a simple (int) myvar then it will give you an error.
Casting from string to int is not possible in C#. You can you int.Parse(somestring) to do that.
What that article is talking about is that this:
string a = somestring ?? "";
is a short way to do this:
string a;
if (somestring == null)
{
a = somestring;
}
else
{
a = "";
}
