How to convert C# nullable int to int

How do I convert a nullable int to an int? Suppose I have 2 type of int as below:

int? v1;  
int v2; 

I want to assign v1's value to v2. v2 = v1; will cause an error. How do I convert v1 to v2?

The other answers so far are all correct; I just wanted to add one more that's slightly cleaner:

v2 = v1 ?? default(int);

Any Nullable<T> is implicitly convertible to its T, PROVIDED that the entire expression being evaluated can never result in a null assignment to a ValueType. So, the null-coalescing operator ?? is just syntax sugar for the ternary operator:

v2 = v1 == null ? default(int) : v1.Value;

...which is in turn syntax sugar for an if/else:

if(v1==null)
   v2 = default(int);
else
   v2 = v1.Value;

---

Also, as of .NET 4.0, Nullable<T> has a "GetValueOrDefault()" method, which is a null-safe getter that basically performs the null-coalescing shown above, so this works too:

v2 = v1.GetValueOrDefault();

Like this,

if(v1.HasValue)
   v2=v1.Value

You can use the Value property for assignment.

v2 = v1.Value;

All you need is..

v2= v1.GetValueOrDefault();

You can't do it if v1 is null, but you can check with an operator.

v2 = v1 ?? 0;

If you know that v1 has a value, you can use the Value property:

v2 = v1.Value;

Using the GetValueOrDefault method will assign the value if there is one, otherwise the default for the type, or a default value that you specify:

v2 = v1.GetValueOrDefault(); // assigns zero if v1 has no value

v2 = v1.GetValueOrDefault(-1); // assigns -1 if v1 has no value

You can use the HasValue property to check if v1 has a value:

if (v1.HasValue) {
  v2 = v1.Value;
}

There is also language support for the GetValueOrDefault(T) method:

v2 = v1 ?? -1;

> GetValueOrDefault()

retrieves the value of the object. If it is null, it returns the default value of int , which is 0.

Example: > v2= v1.GetValueOrDefault();

If the default value for a given type is an acceptable result:

if (v1.HasValue)
v2 = v1.GetValueOrDefault();

If you want a different default value when the result is undefined:

v2 = v1.GetValueOrDefault(255);    // or any valid value for int in place of 255

If you just want the value returned (no matter if the method failed or not):

v2 = v1.GetValueOrDefault();

.NET 4.7.2.: https://referencesource.microsoft.com/mscorlib/R/8b928034cfee7d43.html" title="Reference Source: Nullable<T>.GetValueOrDefault()">GetValueOrDefault() returns the field value without any checking.

As far as I'm concerned the best solution is using GetValueOrDefault() method.

v2 = v1.GetValueOrDefault();

Depending on your usage context, you may use C# 7's pattern-matching feature:

int? v1 = 100;
if (v1 is int v2)
{
    Console.WriteLine($"I'm not nullable anymore: {v2}");
}

###EDIT:### Since some people are downvoting without leaving an explanation, I'd like to add some details to explain the rationale for including this as a viable solution.

• C# 7's pattern matching now allows us check the type of a value and cast it implicitly. In the above snippet, the if-condition will only pass when the value stored in v1 is type-compatible to the type for v2, which in this case is int. It follows that when the value for v1 is null, the if-condition will fail since null cannot be assigned to an int. More properly, null is not an int.

• I'd like to highlight that the that this solution may not always be the optimal choice. As I suggest, I believe this will depend on the developer's exact usage context. If you already have an int? and want to conditionally operate on its value if-and-only-if the assigned value is not null (this is the only time it is safe to convert a nullable int to a regular int without losing information), then pattern matching is perhaps one of the most concise ways to do this.

Int nullable to int conversion can be done like so:

v2=(int)v1;

In C# 7.1 and later, type can be inferred by using the default literal instead of the default operator so it can be written as below:

v2 = v1 ?? default;

it's possible with v2 = Convert.ToInt32(v1);

You could do

v2 = v1.HasValue ? v1.Value : v2;

A simple conversion between v1 and v2 is not possible because v1 has a larger domain of values than v2. It's everything v1 can hold plus the null state. To convert you need to explicitly state what value in int will be used to map the null state. The simplest way to do this is the ?? operator

v2 = v1 ?? 0;  // maps null of v1 to 0

This can also be done in long form

int v2;
if (v1.HasValue) {
  v2 = v1.Value;
} else {
  v2 = 0;
}

It will assign value of v1 to v2 if it is not null, else it will take a default value as zero.

v2=v1??0

Or below is the other way to write it.

v2 = v1.HasValue?v1:0

It can be done using any of the following conversion methods:

v2 = Convert.ToInt32(v1);

v2 = (int)v1;

v2 = v1.GetValueOrDefault();

v2 = v1.HasValue ? v1:0;

 int v2= Int32.Parse(v1.ToString());

I am working on C# 9 and .NET 5, example

foo is nullable int, I need get int value of foo

var foo = (context as AccountTransfer).TransferSide;
int value2 = 0;
if (foo != null)
{
    value2 = foo.Value;
}

See more at https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/nullable-value-types#examination-of-an-instance-of-a-nullable-value-type

Normal TypeConversion will throw an exception

Eg:

int y = 5;    
int? x = null;    
y = x.value; //It will throw "Nullable object must have a value"   
Console.WriteLine(y);

Use Convert.ToInt32() method

int y = 5;    
int? x = null;    
y = x.Convert.ToInt32(x);    
Console.WriteLine(y);

This will return 0 as output because y is an integer.