Kann ich lange in int konvertieren?

Ich möchte konvertieren longzu int.

Wenn der Wert long> ist int.MaxValue, lasse ich ihn gerne herumlaufen.

Was ist der beste Weg?

Tu es einfach (int)myLongValue. Es wird genau das tun, was Sie wollen (MSBs verwerfen und LSBs nehmen) im uncheckedKontext (dies ist die Standardeinstellung des Compilers). Es wird OverflowExceptionin den checkedKontext geworfen, wenn der Wert nicht in Folgendes passt int:

int myIntValue = unchecked((int)myLongValue);

Convert.ToInt32(myValue);

Obwohl ich nicht weiß, was es tun wird, wenn es größer als int.MaxValue ist.

Manchmal interessiert Sie der tatsächliche Wert nicht wirklich, sondern seine Verwendung als Prüfsumme / Hashcode . In diesem Fall ist die integrierte Methode GetHashCode()eine gute Wahl:

int checkSumAsInt32 = checkSumAsIn64.GetHashCode();

Der sicherste und schnellste Weg ist die Verwendung der Bitmaskierung vor dem Wirken ...

int MyInt = (int) ( MyLong & 0xFFFFFFFF )

Der 0xFFFFFFFFWert für Bit Mask ( ) hängt von der Größe von Int ab, da die Größe von Int von der Maschine abhängt.

Es kann konvertieren durch

Convert.ToInt32-Methode

Es wird jedoch eine OverflowException ausgelöst, wenn der Wert außerhalb des Bereichs des Int32-Typs liegt. Ein grundlegender Test zeigt uns, wie es funktioniert:

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.

Hier gibt es eine längere Erklärung.

Würde nicht

(int) Math.Min(Int32.MaxValue, longValue)

mathematisch gesehen der richtige Weg sein?

Die folgende Lösung wird auf int.MinValue / int.MaxValue abgeschnitten, wenn der Wert außerhalb der Ganzzahlgrenzen liegt.

myLong < int.MinValue ? int.MinValue : (myLong > int.MaxValue ? int.MaxValue : (int)myLong)

Eine Möglichkeit besteht darin, den Modulo-Operator zu verwenden, um nur die Werte im int32-Bereich zu belassen, und ihn dann in int umzuwandeln.

var intValue= (int)(longValue % Int32.MaxValue);