I want to convert long
to int
.
If the value of long
> int.MaxValue
, I am happy to let it wrap around.
What is the best way?
This question is related to
c#
types
int
type-conversion
long-integer
It can convert by
Convert.ToInt32 method
But it will throw an OverflowException if it the value is outside range of the Int32 Type. A basic test will show us how it works:
long[] numbers = { Int64.MinValue, -1, 0, 121, 340, Int64.MaxValue };
int result;
foreach (long number in numbers)
{
try {
result = Convert.ToInt32(number);
Console.WriteLine("Converted the {0} value {1} to the {2} value {3}.",
number.GetType().Name, number,
result.GetType().Name, result);
}
catch (OverflowException) {
Console.WriteLine("The {0} value {1} is outside the range of the Int32 type.",
number.GetType().Name, number);
}
}
// The example displays the following output:
// The Int64 value -9223372036854775808 is outside the range of the Int32 type.
// Converted the Int64 value -1 to the Int32 value -1.
// Converted the Int64 value 0 to the Int32 value 0.
// Converted the Int64 value 121 to the Int32 value 121.
// Converted the Int64 value 340 to the Int32 value 340.
// The Int64 value 9223372036854775807 is outside the range of the Int32 type.
Here there is a longer explanation.
Convert.ToInt32(myValue);
Though I don't know what it will do when it's greater than int.MaxValue.
Sometimes you're not actually interested in the actual value, but in its usage as checksum/hashcode. In this case, the built-in method GetHashCode()
is a good choice:
int checkSumAsInt32 = checkSumAsIn64.GetHashCode();
Wouldn't
(int) Math.Min(Int32.MaxValue, longValue)
be the correct way, mathematically speaking?
The safe and fastest way is to use Bit Masking before cast...
int MyInt = (int) ( MyLong & 0xFFFFFFFF )
The Bit Mask ( 0xFFFFFFFF
) value will depend on the size of Int because Int size is dependent on machine.
The following solution will truncate to int.MinValue/int.MaxValue if the value is out of Integer bounds.
myLong < int.MinValue ? int.MinValue : (myLong > int.MaxValue ? int.MaxValue : (int)myLong)
A possible way is to use the modulo operator to only let the values stay in the int32 range, and then cast it to int.
var intValue= (int)(longValue % Int32.MaxValue);
Source: Stackoverflow.com