Megosztás a következőn keresztül:

A lebegőpontos-egész szám konverziók telítettek

  • Cikk

A lebegőpontos-egész szám konverziók mostantól szaturating viselkedést mutatnak az x86- és x64-gépeken. A telítettségi viselkedés azt jelenti, hogy ha a konvertált érték túl kicsi vagy nagy a céltípushoz, az érték az adott típus minimális vagy maximális értékére van beállítva.

Előző viselkedés

Az alábbi táblázat az előző viselkedést mutatja egy vagy double több float érték konvertálásakor.

Konvertálás ... Érték x (Előző) eredmény
int skaláris és csomagolt int.MinValue <= x <= int.MaxValue (int)x
< int.MinValue vagy > int.MaxValue int.MinValue
long skaláris és csomagolt long.MinValue <= x <= long.MaxValue (long)x
< long.MinValue vagy > long.MaxValue long.MinValue
uint skaláris és csomagolt Bármilyen érték (((long)x << 32) >> 32)
ulong skaláris és csomagolt <= 2^63 (long)x
> 2^63 (long)(x - 2^63) + 2^63

Új viselkedés

Az alábbi táblázat az új viselkedést mutatja be egy vagy double több float érték konvertálásakor.

Konvertálás ... Érték x .NET 9+ eredmény
int skaláris és csomagolt int.MinValue <= x <= int.MaxValue (int)x
< int.MinValue int.MinValue
> int.MaxValue int.MaxValue
NaN 0
long skaláris és csomagolt long.MinValue <= x <= long.MaxValue (long)x
< long.MinValue long.MinValue
> long.MaxValue long.MaxValue
NaN 0
uint skaláris és csomagolt 0 <= x <= uint.MaxValue (uint)x
x > uint.MaxValue uint.MaxValue
x < 0 0
ulong skaláris és csomagolt 0 <= x <= ulong.MaxValue (ulong)x
x > ulong.MaxValue ulong.MaxValue
x < 0 0

Bevezetett verzió

.NET 9 előzetes verzió 4

A kompatibilitástörő változás típusa

Ez a változás viselkedésbeli változás.

A változás oka

Ezt a módosítást úgy hajtották végre, hogy az összes lebegőpontos-egész szám konverziót szaturatáló viselkedésre egységesítse, és hogy a viselkedés determinisztikus legyen.

Ha az Előző viselkedés szakaszban látható értékekre támaszkodott, amelyeket vissza kell adni az átalakításból, még akkor is, ha helytelenek voltak, frissítse a kódot, hogy az Új viselkedés szakaszban szereplő értékek jelenjenek meg.

Ha az új viselkedés teljesítményterhelése nem kívánatos a forgatókönyvhöz, használhatja az új ConvertToIntegerNative<TInteger> módszereket az önálló, a dupla és a felezési módszerekkel, amelyek gyorsak. A legtöbb esetben ezeknek a metódusoknak a viselkedése megegyezik az előző lebegőpontos-egész szám konverziós viselkedésével. Ezek a metódusok azonban platformspecifikus viselkedést használnak, amely nem garantáltan megfelel az előző konverziós viselkedésnek (ami már nem determinisztikus volt). Ehelyett ezek a metódusok mindent megtesznek, ami a leghatékonyabb a natív platform számára. Nevezetesen az eredmény nem garantált az olyan értékek esetében, amelyek kívül esnek a TInteger típus ábrázolható tartományán.

A nem gyakori esetben, amikor teljesítményre és az előző konverziós viselkedésnek megfelelő szigorú garanciára van szüksége, használhatja a platformspecifikus hardveres belső elemet. Használhatja például az Sse.ConvertToInt32(Vector128.CreateScalar(val)) függvényt a kezeléshezfloat(int)val. Használat előtt ellenőriznie if (Sse.IsSupported) kell. Ezeknek az intrinsics-eknek a használata azonban bonyolult, mert más célplatformok (például Az Arm64) már más eredményeket eredményeznek.

Érintett API-k

Minden explicit és implicit öntött a lebegőpontostól az egész számig:

  • (int)val where val is a float vagy double
  • Vector.ConvertToInt32(Vector<float> val)
  • (long)val where val is a float vagy double
  • Vector.ConvertToInt64(Vector<double> val)
  • (uint)val where val is a float vagy double
  • Vector.ConvertToUInt32(Vector<float> val)
  • (ulong)val where val is a float vagy double
  • Vector.ConvertToUInt64(Vector<double> val)