Operátori deklarációkkal és túlcsordulással kapcsolatos hibák és figyelmeztetések elhárítása

Ez a cikk a következő fordítóhibákat és figyelmeztetéseket ismerteti:

• CS0031: Az "érték" állandó értéke nem konvertálható típussá
• CS0056: Inkonzisztens hozzáférhetőség: a 'típus' visszatérési típusa kevésbé hozzáférhető, mint az 'operátor'
• CS0057: Inkonzisztens hozzáférhetőség: a "típus" paramétertípus kevésbé hozzáférhető, mint az 'operátor'
• CS0215: A True vagy False operátor visszatérési típusának boolnak kell lennie
• CS0216: Az "operátor" operátorhoz egy "missing_operator" egyező operátort is meg kell határozni
• CS0217: Ahhoz, hogy rövidzárlat-operátorként alkalmazható legyen, a felhasználó által definiált logikai operátornak (operátornak) a 2 paraméter típusával megegyező visszatérési típussal kell rendelkeznie.
• CS0218: A típusnak ('type') igaz operátor deklarációját és hamis operátort kell tartalmaznia
• CS0220: A művelet túlcsordul fordításkor ellenőrzött módban
• CS0221: Az "érték" konstans érték nem alakítható át adott típussá (a felülíráshoz használja az "unchecked" szintaxist)
• CS0448: A ++ vagy -- operátor visszaadási típusának a tartó típusnak kell lennie, vagy a tartó típusból kell származnia
• CS0463: A decimális konstans kifejezés kiértékelése meghiúsult a következő hibával: "hiba"
• CS0543: "enumerálás": az enumerátor értéke túl nagy ahhoz, hogy illeszkedjen a típusához
• CS0552: "konverziós rutin": felhasználó által meghatározott konverzió a felületre vagy a felületről
• CS0553: "konverziós rutin": felhasználó által meghatározott átalakítás alaposztályba vagy abból
• CS0554: "konverziós rutin": felhasználó által meghatározott konverzió származtatott osztályba vagy osztályból
• CS0555: A felhasználó által definiált operátor nem tudja felvenni a beágyazó típus objektumát, és átalakítani egy másik beágyazó típus objektummá
• CS0556: A felhasználó által definiált átalakításnak át kell alakulnia a beágyazási típusra vagy abból
• CS0557: Ismétlődő felhasználói által meghatározott konverzió a típusban
• CS0558: A felhasználó által definiált operátort statikusnak és nyilvánosnak kell deklarálni
• CS0559: A paramétertípusnak vagy ++ operátornak -- a tartalomtípusnak kell lennie
• CS0562: Az unáris operátor paraméterének a tartalmazó típushoz kell tartoznia
• CS0563: A bináris operátor egyik paraméterének a tartalmazó típushoz kell tartoznia
• CS0564: A túlterhelt műszak operátorának első operandusának ugyanazzal a típussal kell rendelkeznie, mint az azt tartalmazó típusnak, és a második operandus típusának intnek kell lennie
• CS0567: A felületek nem tartalmazhatnak operátorokat
• CS0590: A felhasználó által definiált operátorok nem adhatnak vissza érvénytelenséget
• CS0594: A lebegőpontos állandó kívül esik a típus tartományán
• CS0652: Az integrál állandóval való összehasonlítás haszontalan; az állandó kívül esik a típus tartományán
• CS0659: Az "osztály" felülbírálja az Object.Equals(object o) objektumot, de nem bírálja felül az Object.GetHashCode()
• CS0660: A típus definiálja operator == vagy operator !=, de nem bírálja felül Object.Equals(object o)
• CS0661: A típus meghatározza a operator == vagy a operator !=, de nem bírálja felül a Object.GetHashCode()
• CS0715: A statikus osztályok nem tartalmazhatnak felhasználó által definiált operátorokat
• CS1021: Az integrál állandó túl nagy
• CS1037: Túlterhelhető operátor várható
• CS1553: Érvénytelen a deklaráció; használja a "módosító operátor <dest-type> (..." helyette
• CS8930: A felhasználó által definiált operátor explicit implementációját statikusnak kell deklarálni
• CS8931: A felhasználó által definiált átalakításnak a csatolótípusra korlátozott típusparaméterre vagy típusparaméterről kell konvertálnia az illesztőfelületen
• CS8778: Az "érték" állandó érték futásidőben túlcsordulhat a "típus" értéken (a felülbíráláshoz használja a "nem bejelölt" szintaxist)
• CS8973: A művelet futásidőben túlcsordulhat (a felülbíráláshoz használja a "nincs bejelölve" szintaxist)
• CS9023: Az operátor nem ellenőrizhető.
• CS9024: Az operátor nem lehet ellenőrizetlen.
• CS9025: Az operátornak egy egyező, nem ellenőrzött verziót is deklarálnia kell.
• CS9027: Váratlan kulcsszó : "nincs bejelölve".
• CS9308: A felhasználó által definiált operátort nyilvánosan kell deklarálni.
• CS9310: Az operátor visszatérési típusának érvénytelennek kell lennie.
• CS9311: A típus nem implementálja az interfész tagját. A típus nem tudja implementálni a tagot, mert az egyik nem operátor.
• CS9312: A típus nem bírálhatja felül az örökölt tagot, mert az egyik nem operátor.
• CS9313: A túlterhelt összetett hozzárendelés operátora egy paramétert vesz igénybe.
• CS9340: Az operátor nem alkalmazható operandusokra. A legközelebbi nem alkalmazható jelölt jelenik meg.
• CS9341: Az operandusra nem alkalmazható operátor. A legközelebbi nem alkalmazható jelölt jelenik meg.
• CS9342: Az operátorok feloldása nem egyértelmű a következő elemek között.

Az operátorok aláírási követelményei

• CS0448: A ++ vagy -- operátor visszatérési típusának a tároló típusnak kell lennie, vagy abból kell származnia.
• CS0559: A paramétertípusnak vagy ++ operátornak -- a tartalomtípusnak kell lennie.
• CS0562: Az egyváltozós operátor paraméterének a tároló típusnak kell lennie.
• CS0563: A bináris operátorok egyik paraméterének tartalmaznia kell a tartalomtípust.
• CS0564: A túlterhelt műszak operátorának első operandusának ugyanazzal a típussal kell rendelkeznie, mint az azt tartalmazó típusnak, és a második operandus típusának intnek kell lennie.
• CS0567: A felületek nem tartalmazhatnak operátorokat.
• CS0590: A felhasználó által definiált operátorok nem térhetnek vissza semmissé.
• CS9310: Az operátor visszatérési típusának érvénytelennek kell lennie.
• CS9340: Az operátor nem alkalmazható operandusokra. A legközelebbi nem alkalmazható jelölt jelenik meg.
• CS9341: Az operandusra nem alkalmazható operátor. A legközelebbi nem alkalmazható jelölt jelenik meg.
• CS9342: Az operátor feloldása kétértelmű a következő tagok között.

Minden operátortípushoz tartozik egy adott paraméter- és visszatérési típus, amelyet a nyelvi specifikáció határoz meg. Az operátorok túlterhelésére vonatkozó teljes szabályokért tekintse meg az operátorok túlterhelését és a C# specifikációban szereplő operátorokat .

• Változtassa meg a ++ vagy -- operátorok visszatérési típusát az azt tartalmazó típusra vagy az abból származtatott típusra (CS0448). A nyelv megköveteli, hogy a növekményes és a decrement operátorok egy olyan értéket adjanak vissza, amely kompatibilis a tárolótípussal, hogy az eredmény vissza legyen rendelve ugyanahhoz a változóhoz.
• Módosítsa a ++ vagy -- operátorok paraméterét a tartalmazó típusra (CS0559). A növekményes és csökkenő operátoroknak saját típusuk példányain kell működniük.
• Módosítsa egy unáris operátor paraméterét a tartalmazó típusra (CS0562). Az egyváltozós operátoroknak el kell fogadniuk a deklaráló típusú operandust.
• Győződjön meg arról, hogy a bináris operátor legalább egy paramétere a tartalomtípus (CS0563). A bináris operátoroknak tartalmazniuk kell a deklarálás típusát, hogy a fordító ezen a típuson keresztül oldhassa fel őket.
• Módosítsa a shift operátor első paraméterét a tartalmazó típusra, a második paramétert pedig int (CS0564). A nyelv meghatározott szignatúrával definiálja a biteltolási operátorokat: az áthelyezett típust és az eltolás mértékét.
• Operátor-deklarációk áthelyezése az interfészek közül és osztályokba vagy szerkezetekbe (CS0567). A hagyományos (nem statikus absztrakt) operátor-deklarációk nem engedélyezettek az interfészekben. A statikus absztrakt operátorokról az interfészekben lásd: statikus absztrakt és virtuális interfésztagok hibái.
• Módosítsa az operátor visszatérési típusát nem-void típusra (CS0590). A legtöbb felhasználó által definiált operátornak értéket kell visszaadnia. Kivételt képeznek az összetett hozzárendelési operátorok, amelyek visszatérési típust void (CS9310) igényelnek.
• Javítsa ki a paramétertípusokat, vagy adjon hozzá hiányzó operátor-túlterheléseket, hogy a fordító megkeresse a hívási helyen használt operandustípusoknak megfelelő operátort (CS9340, CS9341). Ha nincs megfelelő operátor, a fordító megjeleníti a legközelebbi jelöltet a nem egyezés diagnosztizálásához.
• Adjon hozzá explicit konverziókat a hívási helyen, vagy adjon pontosabb overloadokat, hogy kiküszöbölje a kétértelműséget, ha több operátor overloadja ugyanolyan jól illeszkedik (CS9342).

Fontos

A statikus bináris operátorok és a megfelelő példány-összetett hozzárendelési operátorok aláírási követelményei eltérőek. Győződjön meg arról, hogy az aláírás megegyezik a kívánt deklarációval.

Az operátorok deklarálási követelményei

• CS0558: A felhasználó által definiált operátort statikusnak és nyilvánosnak kell deklarálni.
• CS0715: A statikus osztályok nem tartalmazhatnak felhasználó által definiált operátorokat.
• CS1037: Túlterhelhető operátor várható.
• CS1553: A deklaráció érvénytelen; használja a "módosító operátor <dest-type> (..." helyette.
• CS9308: A felhasználó által definiált operátort nyilvánosan kell deklarálni.

A nyelvhez meghatározott módosítókra és szintaxisra van szükség az operátor-deklarációkhoz. A teljes szabályokért tekintse meg az operátorok túlterhelését és a felhasználó által definiált konverziós operátorokat.

• Adja hozzá mind a static és public módosítókat az operátor deklarációhoz (CS0558, CS9308). A C#-nyelv megköveteli, hogy a felhasználó által definiált operátorok statikusak és nyilvánosak legyenek, hogy példány nélkül is elérhetők és hívhatók legyenek.
• Helyezze át az operátor-deklarációt egy statikus osztályból egy nem statikus osztályba vagy szerkezetbe (CS0715). A statikus osztályok nem rendelkezhetnek példányokkal, ezért a felhasználó által definiált operátorok – amelyek a bennük található példányokon működnek – nem értelmezhetők statikus osztályokban.
• Cserélje le az érvénytelen operátorszimbólumot egy érvényes túlterhelhető operátorra (CS1037). Csak a nyelv által meghatározott operátorok terhelhetők túl.
• Javítsa ki a szintaxist a szükséges konverziós operátor űrlapjának követéséhez: public static implicit operator <dest-type>(<source-type> parameter) vagy public static explicit operator <dest-type>(<source-type> parameter) (CS1553). A fordító elvárja, hogy a konverziós operátorok egy adott deklarációs mintát kövessenek.

A statikus absztrakciós felületek operátorainak explicit felületi implementációival kapcsolatos hibákért tekintse meg a statikus absztrakt és a virtuális felület taghibáit.

Inkonzisztens akadálymentesség

• CS0056: Inkonzisztens hozzáférhetőség: a 'típus' visszatérési típus kevésbé hozzáférhető, mint az 'operátor'.
• CS0057: Inkonzisztens hozzáférhetőség: a "típus" paramétertípus kevésbé hozzáférhető, mint az operátor.

A nyilvános operátor aláírásában használt összes típusnak legalább olyan elérhetőnek kell lennie, mint maga az operátor. A teljes szabályokat a C#-specifikáció accessmódosítói és akadálymentességi korlátozásai című témakörben talál.

• Módosítsa a visszatérési típust olyan típusra, amely legalább olyan akadálymentes, mint az operátor, vagy csökkentse az operátor akadálymentességét a visszatérési típusnak (CS0056) megfelelően. Az public operátor nem tehet közzé kevésbé hozzáférhető típust a visszatérési értékén keresztül, mert a szerelvényen kívüli hívók nem tudnák használni az eredményt.
• Módosítsa a paramétertípust olyan típusra, amely legalább olyan elérhető, mint az operátor, vagy csökkentse az operátor akadálymentességét a paramétertípusnak (CS0057) megfelelően. Az public operátorok nem igényelhetnek kevésbé akadálymentes típust paraméterként, mert a szerelvényen kívüli hívók nem tudnák megadni az argumentumot.

Felhasználó által meghatározott konverziós korlátozások

• CS0552: Felhasználó által definiált átalakítás felületre vagy felületről.
• CS0553: Felhasználó által definiált átalakítás alaposztályra vagy alaposztályból.
• CS0554: Felhasználó által definiált átalakítás származtatott osztályba vagy osztályból.
• CS0555: A felhasználó által definiált operátor nem vehet fel egy objektumot a beágyazási típusból, és nem konvertálható a beágyazási típus objektumává.
• CS0556: A felhasználó által definiált átalakításnak át kell alakulnia a beágyazás típusára vagy típusáról.
• CS0557: A felhasználó által definiált átalakítás duplikálása típusban.

A C# nyelv korlátozza, hogy mely típusok vehetnek részt a felhasználó által definiált konverziókban. A teljes szabályokért tekintse meg a felhasználó által definiált konverziós operátorokat és a C# specifikációban szereplő konverziós operátorokat .

• Távolítsa el az illesztőtípusra vagy illesztőtípusból konvertáló átalakítási operátort (CS0552). A nyelv tiltja a felhasználó által definiált, felülettípusokat érintő konverziókat, mert az interfész-átalakítások kezelése a típusrendszer referenciakonvertálásán és dobozolásán keresztül történik. Használjon explicit felületi implementációkat vagy segédmetódusokat.
• Távolítsa el az alaposztállyal való átváltást végző operátort (CS0553). A típus és az alaposztály közötti konverziók már léteznek implicit referenciakonvertálások (felkonvertálás) és explicit referenciakonvertálások (lekonvertálás) révén, így a felhasználó által definiált konverzió kétértelműséget eredményezne.
• Távolítsa el azt az átalakító operátort, amely származtatott osztályba vagy onnan konvertál (CS0554). Az alaposztály-konverziókhoz hasonlóan a típus és a származtatott típusok közötti konverziók örökléssel vannak beépítve a nyelvbe, és a felhasználó által megadott konverziók ütköznének velük.
• Távolítsa el a beágyazási típust önmagává konvertáló konverziós operátort (CS0555). Minden típus már rendelkezik implicit identitásátalakítással, így a felhasználó által definiált átalakítás egy típusról ugyanarra a típusra redundáns, és nem engedélyezett.
• Módosítsa a konvertálási operátor egyik típusát úgy, hogy a forrás vagy a cél típusa legyen a beágyazási típus (CS0556). A felhasználó által definiált átalakításnak tartalmaznia kell azt a típust, amely deklarálja azt – harmadik típusban nem definiálhat konverziót két nem kapcsolódó külső típus között.
• Távolítsa el a duplikált átalakítási operátort, vagy módosítsa az egyik ismétlődő operátort, hogy a forrás- és céltípusok eltérhessenek a másiktól (CS0557). Egy típus csak egy implicit és egy explicit konverziót deklarálhat az adott forrás- és céltípusokhoz.

Logikai és rövidzárlat-operátorok

• CS0215: Az igaz vagy hamis operátor visszatérési típusának boolnak kell lennie.
• CS0216: Az operátornak meg kell határoznia egyező operátort is.
• CS0217: Ahhoz, hogy rövidzárlat-operátorként alkalmazható legyen, a felhasználó által definiált logikai operátornak ugyanazzal a visszatérési típussal kell rendelkeznie, mint a 2 paraméter típusa.
• CS0218: A típusnak igaz és hamis operátor deklarációit kell tartalmaznia.

A C#-nyelvhez meghatározott párosításokra és aláírásokra van szükség a logikai operátorokhoz és a rövidzárlat-kiértékeléshez. A teljes szabályok megismeréséhez tekintse meg az igaz és hamis operátorokat, a logikai operátorokat és a felhasználó által definiált feltételes logikai operátorokat a C# specifikációban.

• Módosítsa a operator true és a operator false visszatérési típusát bool típusra (CS0215). Ezek az operátorok határozzák meg, hogy egy érték logikailag igaz vagy hamis-e, ezért a nyelv megköveteli a visszatérést bool.
• Adja meg az egyező párosított operátort (CS0216). A nyelv megköveteli, hogy egyes operátorok párban legyenek deklarálva: operator == a következőkkeloperator !=, operator < a következőkkel operator >operator <=operator >=operator trueoperator false:
• Módosítsa a felhasználó által definiált & vagy | operátor visszatérési típusát úgy, hogy az megfeleljen mindkét paramétertípusnak (CS0217). A rövidzárlat kiértékeléséhez (&& és ||) a fordítónak szüksége van arra, hogy a & vagy a | operátor visszatérési típusa, mindkét paraméter típusa és a tartalmazó típus ugyanaz legyen.
• Adjon hozzá mindkettőt operator true és operator false deklarációt a típushoz (CS0218). A fordító újraírja &&, || a operator true, operator false és a megfelelő & vagy | operátor segítségével, így mindháromnak jelen kell lennie a rövidzárlat-értékelés működéséhez.

Ellenőrzött operátorok

• CS9023: Az operátor nem ellenőrizhető
• CS9024: Az operátor nem állítható be ellenőrizetlenre
• CS9025: Az ellenőrzött operátornak egy egyező, nem ellenőrzött verziót is deklarálnia kell
• CS9027: Váratlan kulcsszó : "nincs bejelölve"

A checked kulcsszavak és unchecked a kulcsszavak csak adott operátor-deklarációkra alkalmazhatók. A teljes szabályokért tekintse meg az Aritmetikai operátorokat és a felhasználó által megadott ellenőrzött operátorokat.

• Távolítsa el a checked vagy a unchecked kulcsszót egy nem támogatott operátorból (CS9023, CS9024). Csak az aritmetikai operátorok +, -, , */, , ++, , --és explicit konverziós operátorok támogatják az ellenőrzött és a nem ellenőrzött változatokat. Egyéb operátorok, mint például az összehasonlító vagy egyenlőségi operátorok, nem rendelkeznek külön túlcsordulási viselkedéssel, és nem jelölhetők be az ellenőrzött vagy nem ellenőrzött állapotban.
• Adja hozzá az operátor (CS9025) egyező, nem ellenőrzött verzióját. Az checked operátor biztosítja a túlcsordulási viselkedést, de a fordítónak a megfelelő nem ellenőrzött verzióra is szüksége van a környezetekben unchecked való használathoz, és alapértelmezettként, ha egyik környezet sincs megadva.
• Távolítsa el a kulcsszót unchecked az érvénytelen pozícióból (CS9027). Az unchecked operátordeklarációban szereplő kulcsszó csak az operátor szintaxisának részeként érvényes (például public static explicit operator unchecked int(MyType t)). Ha máshová helyezzük a deklarációban, szintaxishibát okoz.

Interfész- és öröklési követelmények

• CS9311: A típus nem implementálja a felület tagját. A típus nem tudja implementálni a tagot, mert az egyik nem operátor
• CS9312: A típus nem bírálhatja felül az örökölt tagot, mert az egyik nem operátor
• CS9313: A túlterhelt összetett hozzárendelés operátora egy paramétert vesz igénybe

A fordító szigorú egyeztetést kényszerít ki az operátor-deklarációk és az általuk implementálható vagy felülbírálható felülettagok vagy alaposztálytagok között. A teljes szabályokért tekintse meg az operátorok túlterhelését és az interfészeket.

• Módosítsa a implementáló tagot az interfész operátortagjának megfelelő operátori deklarációra, vagy módosítsa az illesztő tagot metódusra, ha a implementáló tag metódus (CS9311). Az operátorok csak olyan illesztőtagot implementálhatnak, amely szintén operátorként van deklarálva – az operátori szerződéseket nem lehet normál módszerrel teljesíteni, vagy fordítva.
• Módosítsa a felülíró tagot az alaposztály operátortagjának megfelelő operátordeklarációra, vagy módosítsa az alaposztály tagját metódusra, ha a származtatott osztálytag egy metódus (CS9312). A felület implementálásához hasonlóan a felülbírálásnak is meg kell egyeznie a felülbírált tag típusával – az operátorok nem bírálhatnak felül egy nem operátor tagot.
• Módosítsa az összetett hozzárendelés operátorának deklarációját úgy, hogy pontosan egy paramétert (CS9313) fogadjon el. Az összetett hozzárendelési operátorok olyan példánytagok, amelyekben a bal operandus implicit módon thisjelenik meg, ezért csak a jobb oldali operandus lesz paraméterként deklarálva.

Egyenlőségi operátorok

• CS0659: Az "osztály" felülbírálja az Object.Equals(object o) objektumot, de nem bírálja felül az Object.GetHashCode()
• CS0660: A típus == vagy operátor != operátort definiál, de nem bírálja felül az Object.Equals(object o) függvényt.
• CS0661: A típus == vagy operátor != operátort definiál, de nem bírálja felül az Object.GetHashCode()

A fordító megköveteli, hogy az egyenlőséghez kapcsolódó felülbírálások és operátordefiníciók szinkronban maradjanak. Amikor felülbírálja a Object.Equals-t vagy definiálja a operator == / operator !=-t, a kapcsolódó felülbírálásokat is meg kell adnia. A teljes szabályokért lásd: Értékegyenlőség definiálása típushoz és Egyenlőség operátorokhoz.

• Amikor Object.GetHashCode felülbírálja, adjon hozzá egy Object.Equals felülbírálást (CS0659 esetén). A hash-alapú gyűjtemények, mint Dictionary<TKey,TValue> és HashSet<T>, támaszkodnak arra a szerződésre, hogy két egyenlő objektumnak ugyanazt a kivonatkódot kell visszaadnia. Egyező GetHashCode felülbírálás nélkül az egyenlőként összehasonlított objektumok a különböző gyűjtőkbe kerülhetnek, ami miatt a keresések és a deduplikáció sikertelenül és észrevétlenül végződhetnek.
• Határozza meg a felülbírálást Object.Equals, amikor operator == vagy operator != definiálja (CS0660 esetén). A közvetlenül hívható Equals kód – beleértve számos keretrendszer API-t, LINQ-metódust és gyűjtési műveletet – nem fogja használni az egyéni operátort. Konzisztens Equals felülbírálás nélkül előfordulhat, hogy ugyanazon két objektumot == egyenlőnek tekinti, míg Equals nem, ami váratlan viselkedéshez vezethet.
• Adjon hozzá felülbírálást Object.GetHashCode a definiáláskor operator == vagy operator != a (CS0661)-ben. A CS0659 például következetességet követel meg az egyenlőségi szemantikák terén. Ha operator == két objektumot egyenlőnek tekint, de eltérő kivonatkódokat adnak vissza, a kivonatalapú gyűjtemények nem fognak megfelelően működni.

Túlcsordulási és alulcsordulási hibák

• CS0031: Az "érték" állandó értéke nem konvertálható típussá
• CS0220: A művelet túlcsordulást okoz fordításkor egy ellenőrzött módban
• CS0221: Az 'érték' állandóértéket nem lehet 'típus'-ra konvertálni (használja az 'unchecked' szintaxist a felülbíráláshoz)
• CS0463: A decimális konstans kifejezés kiértékelése meghiúsult a következő hibával: "hiba"
• CS0543: "enumerálás": az enumerátor értéke túl nagy ahhoz, hogy illeszkedjen a típusához
• CS0594: A lebegőpontos állandó kívül esik a(z) 'type' típus tartományán
• CS0652: Az integrál állandóval való összehasonlítás haszontalan; az állandó kívül esik a típus tartományán
• CS1021: Az integrál állandó túl nagy
• CS8778: Az "érték" állandó érték futásidőben túlcsordulhat a "típus" értéken (a felülbíráláshoz használja a "nem bejelölt" szintaxist)
• CS8973: A művelet futásidőben túlcsordulhat (a felülbíráláshoz használja a "nincs bejelölve" szintaxist)

A fordító a fordításkor kiértékeli az állandó kifejezéseket, és hibákat vagy figyelmeztetéseket jelez, ha egy érték túllépi a céltípus érvényes tartományát. A teljes szabályokért tekintse meg az ellenőrzött és a nem ellenőrzött utasításokat és az integráltípusokat.

• Módosítsa az állandó értéket a céltípus tartományán belülre illeszkedő értékre, vagy módosítsa a célértéket egy nagyobb számtípusra (CS0031). A fordító nem tud automatikusan egy állandót szűkíteni, amely nem fér bele – például amikor 256-t szeretnénk hozzárendelni egy byte értékhez (0–255 tartományban), ez a hiba jelentkezik. Ha a csonkolás szándékos, használjon explicit típuskonverziót egy unchecked környezetben.
• Javítsa ki az aritmetikai adatokat az állandó kifejezésben, hogy az eredmény illeszkedjen a céltípushoz, vagy csomagolja a kifejezést egy nem ellenőrzött környezetbe, hogy lehetővé tegye a csendes túlcsordulást (CS0220). A fordító alapértelmezés szerint kiértékeli a teljes állandó kifejezést fordításkor egy ellenőrzött környezetben, így a típus tartományát meghaladó köztes vagy végleges eredmények okozzák ezt a hibát.
• Módosítsa az állandó értéket, vagy a céltípust úgy, hogy az átalakítás érvényes legyen, vagy ha a csonkolt eredményt szándékosan szeretné, csomagolja be az unchecked kódot egy kontextusba. A CS0220-sal ellentétben ez a hiba olyan explicit állandó konverziókra vonatkozik, ahol a forrásérték nem felel meg a céltípusnak.
• Egyszerűsítse vagy bontsa szét az decimal állandó kifejezést, hogy a típus tartományán és pontosságán decimal belül maradjon (CS0463). A decimal típus maximális értéke körülbelül $7,9 \times 10^{28}$ és 28–29 jelentős számjegy, és a fordító a fordításkor kiértékeli a teljes kifejezést.
• Módosítsa az enumerálási tag értékét olyanná, amely illeszkedik az enum alapjául szolgáló típusába, vagy módosítsa az alapul szolgáló típust egy nagyobb egész típusra (CS0543). Alapértelmezés szerint a felsorolási típusok a int típust használják alapul. Ha egy tag értéke meghaladja a mögöttes típus tartományát, adjon meg egy nagyobb típust, például long.
• Módosítsa a lebegőpontos állandót a céltípus tartományán belüli értékre, vagy használjon egy nagyobb pontosságú típust, mint például double ahelyett, hogy float-t alkalmazna (CS0594). A float típus körülbelül $3,4 \times 10^{38}$ értékig támogatja az értékeket, és double legfeljebb 1,7 $ \times 10^{308}$ értéket támogat.
• Távolítsa el vagy javítsa ki az összehasonlítást, hogy az állandó a változó típusának tartományán belül legyen (CS0652). Ha például egy változót byte összehasonlít egy változóval 300, az soha nem lehet igaz, ezért a fordító figyelmezteti, hogy az összehasonlítás használhatatlan. Ez a figyelmeztetés gyakran logikai hibát vagy eltérést jelez a változó típusa és a kívánt értéktartomány között.
• Használjon nagyobb numerikus típust, vagy ossza fel az értéket több műveletre (CS1021). Ez a hiba akkor fordul elő, ha egy egész számkonstans túllépi még a legnagyobb integráltípus tartományát is (ulonglegfeljebb 1,8 $ \times 10^{19}$). Az ezen a tartományon túli értékeknél érdemes lehet a következőt használni BigInteger: .
• A kifejezés unchecked körbefuttatásával letilthatja a figyelmeztetést, vagy módosíthatja az értéket úgy, hogy illeszkedjen a céltípus tartományán belülre (CS8778). Ez a figyelmeztetés állandó konverziót jelez, amely futásidőben adatvesztést okozhat – a fordító nem tudja bizonyítani, hogy a túlcsordulás biztosan bekövetkezik, de azonosítja a kockázatot.
• Csomagolja be a kifejezést egy unchecked kontextusba a figyelmeztetés mellőzéséhez, vagy strukturálja át az aritmetikát a lehetséges túlcsordulás elkerülése érdekében (CS8973). Ez a figyelmeztetés hasonló a CS8778-hoz , de konverziók helyett aritmetikai műveletekre vonatkozik – a fordító észleli, hogy a művelet futásidőben túlcsordulhat.