Risolvere gli errori e gli avvisi per le dichiarazioni degli operatori e le situazioni di overflow

Questo articolo illustra gli errori e gli avvisi del compilatore seguenti:

• CS0031: Il valore costante 'value' non può essere convertito in un 'type'
• CS0056: accessibilità incoerente: il tipo restituito 'type' è meno accessibile dell'operatore 'operator'
• CS0057: accessibilità incoerente: il tipo di parametro 'type' è meno accessibile dell'operatore 'operator'
• CS0215: il tipo restituito di operatore True o False deve essere bool
• CS0216: l'operatore 'operator' richiede anche la definizione di un operatore corrispondente 'missing_operator'
• CS0217: per essere applicabile come operatore a corto circuito, un operatore logico definito dall'utente ('operator') deve avere lo stesso tipo restituito del tipo dei relativi 2 parametri.
• CS0218: il tipo ('type') deve contenere dichiarazioni di operatore true e operator false
• CS0220: l'operazione va in overflow in fase di compilazione in modalità controllata
• CS0221: Impossibile convertire il valore costante 'value' in un 'type' (usare la sintassi 'unchecked' per eseguire l'override)
• CS0448: il tipo restituito per ++ o -- operatore deve essere il tipo contenitore o derivato dal tipo contenitore
• CS0463: Valutazione dell'espressione costante decimale non riuscita con errore: 'error'
• CS0543: 'enumerazione': il valore dell'enumeratore è troppo grande per adattarsi al tipo
• CS0552: 'routine di conversione': conversione definita dall'utente in/dall'interfaccia
• CS0553: 'routine di conversione': conversione definita dall'utente in/dalla classe base
• CS0554: 'conversion routine' : conversione definita dall'utente in/da classe derivata
• CS0555: l'operatore definito dall'utente non può accettare un oggetto del tipo di inclusione e convertirlo in un oggetto del tipo di inclusione
• CS0556: la conversione definita dall'utente deve essere verso o da il tipo contenitore
• CS0557: conversione definita dall'utente duplicata nel tipo
• CS0558: l'operatore definito dall'utente deve essere dichiarato statico e pubblico
• CS0559: il tipo di parametro per ++ o -- l'operatore deve essere il tipo contenitore
• CS0562: il parametro di un operatore unario deve essere il tipo contenitore
• CS0563: uno dei parametri di un operatore binario deve essere il tipo contenitore
• CS0564: il primo operando di un operatore di spostamento sovraccarico deve avere lo stesso tipo del tipo contenente e il tipo del secondo operando deve essere int
• CS0567: Le interfacce non possono contenere operatori
• CS0590: gli operatori definiti dall'utente non possono restituire void
• CS0594: La costante a virgola mobile è al di fuori dell'intervallo del tipo 'type'
• CS0652: il confronto con la costante integrale è inutile; la costante non rientra nell'intervallo di tipo 'type'
• CS0659: 'class' esegue l'override di Object.Equals(object o) ma non esegue l'override di Object.GetHashCode()
• CS0660: il tipo definisce operator == o operator != ma non esegue l'override Object.Equals(object o)
• CS0661: il tipo definisce operator == o operator != ma non esegue l'override Object.GetHashCode()
• CS0715: Le classi statiche non possono contenere operatori definiti dall'utente
• CS1021: la costante integrale è troppo grande
• CS1037: Previsto operatore sovraccaricabile
• CS1553: La dichiarazione non è valida; usare 'modifier operator <dest-type> (...' invece
• CS8930: L'implementazione esplicita di un operatore definito dall'utente deve essere dichiarata statica
• CS8931: la conversione definita dall'utente in un'interfaccia deve eseguire la conversione in o da un parametro di tipo nel tipo di inclusione vincolato al tipo di inclusione
• CS8778: Il valore costante 'value' potrebbe causare un overflow di 'type' in fase di esecuzione (usare la sintassi 'unchecked' per ignorarlo)
• CS8973: l'operazione potrebbe causare un overflow in fase di esecuzione (usare la sintassi 'unchecked' per override)
• CS9023: Impossibile controllare l'operatore.
• CS9024: L'operatore non può essere reso non verificato.
• CS9025: l'operatore richiede anche la dichiarazione di una versione non controllata corrispondente.
• CS9027: parola chiave imprevista 'unchecked'.
• CS9308: l'operatore definito dall'utente deve essere dichiarato pubblico.
• CS9310: il tipo restituito per questo operatore deve essere void.
• CS9311: il tipo non implementa il membro dell'interfaccia. Il tipo non può implementare il membro perché uno di essi non è un operatore.
• CS9312: il tipo non può eseguire l'override del membro ereditato perché uno di essi non è un operatore.
• CS9313: L'operatore di assegnazione composto sovraccarico accetta un parametro.
• CS9340: l'operatore non può essere applicato agli operandi. Viene visualizzato il candidato inapplicabile più vicino.
• CS9341: l'operatore non può essere applicato all'operando. Viene visualizzato il candidato inapplicabile più vicino.
• CS9342: La risoluzione degli operatori è ambigua tra i membri elencati di seguito.

Requisiti di firma dell'operatore

• CS0448: il tipo restituito per ++ o -- operatore deve essere il tipo contenitore o derivato dal tipo contenitore.
• CS0559: il tipo di parametro per ++ o -- operatore deve essere il tipo contenitore.
• CS0562: il parametro di un operatore unario deve essere il tipo contenitore.
• CS0563: uno dei parametri di un operatore binario deve essere il tipo contenitore.
• CS0564: il primo operando di un operatore di spostamento sovraccaricato deve avere lo stesso tipo del tipo che lo contiene e il tipo del secondo operando deve essere int.
• CS0567: le interfacce non possono contenere operatori.
• CS0590: gli operatori definiti dall'utente non possono restituire void.
• CS9310: il tipo restituito per questo operatore deve essere void.
• CS9340: l'operatore non può essere applicato agli operandi. Viene visualizzato il candidato inapplicabile più vicino.
• CS9341: l'operatore non può essere applicato all'operando. Viene visualizzato il candidato inapplicabile più vicino.
• CS9342: La risoluzione dell'operatore è ambigua tra i membri seguenti.

Ogni tipo di operatore ha requisiti di tipo restituito e di parametro specifici definiti dalla specifica del linguaggio. Per le regole complete su cui è possibile eseguire il sovraccarico degli operatori, vedere Sovraccarico degli operatori e Operatori nella specifica C#.

• Modificare il tipo restituito degli operatori ++ o -- al tipo contenitore o a un tipo derivato (CS0448). Il linguaggio richiede che gli operatori di incremento e decremento restituiscono un valore compatibile con il tipo contenitore in modo che il risultato possa essere assegnato alla stessa variabile.
• Modificare il parametro degli operatori ++ o -- nel tipo contenitore (CS0559). Gli operatori di incremento e decremento devono operare su istanze del proprio tipo.
• Modificare il parametro di un operatore unario nel tipo contenitore (CS0562). Gli operatori unari devono accettare un operando del tipo che li dichiara.
• Verificare che almeno un parametro di un operatore binario sia il tipo contenitore (CS0563). Gli operatori binari devono includere il tipo dichiarante in modo che il compilatore possa risolverli tramite tale tipo.
• Modificare il primo parametro di un operatore shift al tipo contenitore e il secondo parametro a int (CS0564). Il linguaggio definisce gli operatori di spostamento con una signature specifica: il tipo spostato e una quantità di spostamento intero.
• Spostare le dichiarazioni degli operatori dalle interfacce alle classi o alle struct (CS0567). Le dichiarazioni di operatore tradizionali (astratte non statiche) non sono consentite nelle interfacce. Per gli operatori astratti statici nelle interfacce, vedere Errori dei membri di interfaccia astratta e virtuale statici.
• Modificare il tipo restituito dell'operatore in un tipo non void (CS0590). La maggior parte degli operatori definiti dall'utente deve restituire un valore. L'eccezione è costituita da operatori di assegnazione composti, che richiedono un void tipo restituito (CS9310).
• Correggere i tipi di parametro o aggiungere gli overload degli operatori mancanti affinché il compilatore possa trovare un operatore corrispondente per i tipi di operando utilizzati nel sito di chiamata (CS9340, CS9341). Se non esiste alcun operatore applicabile, il compilatore mostra il candidato più vicino per diagnosticare la mancata corrispondenza.
• Aggiungere cast espliciti nel punto di chiamata o fornire overload più specifici per eliminare l'ambiguità quando più overload di operatore corrispondono altrettanto bene (CS9342).

Importante

I requisiti di firma per gli operatori binari statici e i corrispondenti operatori di assegnazione composta di istanza sono diversi. Assicurarsi che la firma corrisponda alla dichiarazione desiderata.

Requisiti di dichiarazione dell'operatore

• CS0558: l'operatore definito dall'utente deve essere dichiarato statico e pubblico.
• CS0715: le classi statiche non possono contenere operatori definiti dall'utente.
• CS1037: Previsto operatore sovraccaricabile.
• CS1553: La dichiarazione non è valida; usare 'modifier operator <dest-type> (...' invece.
• CS9308: l'operatore definito dall'utente deve essere dichiarato pubblico.

Il linguaggio richiede modificatori e sintassi specifici per le dichiarazioni degli operatori. Per le regole complete, vedere Sovraccarico degli operatori e Operatori di conversione definiti dall'utente.

• Aggiungere entrambi i static modificatori e public alla dichiarazione dell'operatore (CS0558, CS9308). Il linguaggio C# richiede che tutti gli operatori definiti dall'utente siano statici e pubblici in modo che siano accessibili e chiamabili senza un'istanza.
• Spostare la dichiarazione dell'operatore da una classe statica in una classe o uno struct non statico (CS0715). Le classi statiche non possono avere istanze, quindi gli operatori definiti dall'utente, che operano su istanze del tipo contenitore, non sono significativi nelle classi statiche.
• Sostituire il simbolo dell'operatore non valido con un operatore di overload valido (CS1037). È possibile eseguire l'overload solo di operatori specifici definiti dal linguaggio.
• Correggere la sintassi per seguire il formato dell'operatore di conversione richiesto: public static implicit operator <dest-type>(<source-type> parameter) o public static explicit operator <dest-type>(<source-type> parameter) (CS1553). Il compilatore prevede che gli operatori di conversione seguano un modello di dichiarazione specifico.

Per gli errori correlati alle implementazioni esplicite dell'interfaccia degli operatori nelle interfacce astratte statiche, vedere Errori dei membri di interfaccia astratta e virtuale statici.

Accessibilità incoerente

• CS0056: accessibilità incoerente: il tipo restituito 'type' è meno accessibile dell'operatore 'operator'.
• CS0057: accessibilità incoerente: il tipo di parametro 'type' è meno accessibile dell'operatore 'operator'.

Tutti i tipi usati nella firma di un operatore pubblico devono essere altrettanto accessibili quanto l'operatore stesso. Per le regole complete, vedere Modificatori di accesso e vincoli di accessibilità nella specifica C#.

• Modificare il tipo restituito in un tipo accessibile almeno quanto l'operatore, oppure ridurre l'accessibilità dell'operatore per farla corrispondere al tipo restituito (CS0056). Un public operatore non può esporre un tipo meno accessibile tramite il relativo valore restituito perché i chiamanti esterni all'assembly non sarebbero in grado di usare il risultato.
• Modificare il tipo di parametro in un tipo accessibile almeno come l'operatore oppure ridurre l'accessibilità dell'operatore in modo che corrisponda al tipo di parametro (CS0057). Un public operatore non può richiedere un tipo meno accessibile come parametro perché i chiamanti esterni all'assembly non sarebbero in grado di fornire l'argomento.

Restrizioni di conversione definite dall'utente

• CS0552: conversione definita dall'utente in/dall'interfaccia.
• CS0553: conversione definita dall'utente in/dalla classe di base.
• CS0554: conversione definita dall'utente in/dalla classe derivata.
• CS0555: l'operatore definito dall'utente non può accettare un oggetto del tipo di inclusione e convertirlo in un oggetto del tipo di inclusione.
• CS0556: La conversione definita dall'utente deve essere verso o da il tipo contenitore.
• CS0557: Conversione definita dall'utente duplicata nel tipo.

Il linguaggio C# limita i tipi che possono partecipare alle conversioni definite dall'utente. Per le regole complete, vedere Operatori di conversione definiti dall'utente e Operatori di conversione nella specifica C#.

• Rimuovere l'operatore di conversione che esegue la conversione in o da un tipo di interfaccia (CS0552). Il linguaggio impedisce conversioni definite dall'utente che coinvolgono tipi di interfaccia perché le conversioni di interfaccia vengono gestite tramite le conversioni di riferimento e il boxing del sistema dei tipi. Usare invece implementazioni esplicite dell'interfaccia o metodi helper.
• Rimuovere l'operatore di conversione che esegue la conversione in o da una classe base (CS0553). Le conversioni tra un tipo e la relativa classe di base esistono già tramite conversioni di riferimento implicite (upcast) e conversioni di riferimenti esplicite (downcast), in modo che una conversione definita dall'utente crei ambiguità.
• Rimuovere l'operatore di conversione che esegue la conversione in o da una classe derivata (CS0554). Analogamente alle conversioni di classi base, le conversioni tra un tipo e i relativi tipi derivati vengono incorporate nel linguaggio tramite ereditarietà e le conversioni definite dall'utente potrebbero essere in conflitto con esse.
• Rimuovere l'operatore di conversione che converte il tipo contenitore in se stesso (CS0555). Ogni tipo ha già una conversione implicita di identità a se stessa, pertanto una conversione definita dall'utente da un tipo allo stesso tipo è ridondante e non consentita.
• Modificare uno dei tipi nell'operatore di conversione in modo che il tipo di origine o di destinazione sia il tipo di inclusione (CS0556). Una conversione definita dall'utente deve includere il tipo che lo dichiara: non è possibile definire una conversione tra due tipi esterni non correlati in un terzo tipo.
• Rimuovere l'operatore di conversione duplicato o modificare uno degli operatori duplicati in modo che i tipi di origine e di destinazione differiscano dall'altro (CS0557). Un tipo può dichiarare solo una conversione implicita e una conversione esplicita per qualsiasi coppia di tipi di origine e di destinazione specificati.

Operatori booleani e a corto circuito

• CS0215: il tipo restituito di operatore true o false deve essere bool.
• CS0216: l'operatore richiede anche la definizione di un operatore corrispondente.
• CS0217: per essere applicabile come operatore a corto circuito, un operatore logico definito dall'utente deve avere lo stesso tipo restituito del tipo dei relativi 2 parametri.
• CS0218: il tipo deve contenere dichiarazioni di operatore true e operator false.

Il linguaggio C# richiede associazioni e firme specifiche per gli operatori booleani e la valutazione a corto circuito. Per le regole complete, vedere operatori true e false, operatori logici booleani e operatori logici definiti dall'utente nella specifica C#.

• Modificare il tipo restituito di operator true e operator false in bool (CS0215). Questi operatori determinano se un valore è logicamente true o false, quindi il linguaggio richiede che restituisca bool.
• Definire l'operatore associato corrispondente (CS0216). Il linguaggio richiede che determinati operatori siano dichiarati in coppie: operator == con operator !=, operator < con operator >, operator <= con operator >= e operator true con operator false.
• Modificare il tipo restituito dell'operatore definito dall'utente & o | in modo che corrisponda a entrambi i tipi di parametro (CS0217). Per la valutazione a corto circuito (&& e ||), il compilatore richiede che il tipo di ritorno dell'operatore & o |, entrambi i tipi di parametro, e il tipo contenitore siano tutti dello stesso tipo.
• Aggiungere sia le dichiarazioni operator true che operator false al tipo (CS0218). Il compilatore riscrive && e || utilizzando operator true, operator false, e l'operatore & o il corrispondente |, pertanto tutti e tre devono essere presenti per il funzionamento della valutazione a corto circuito.

Operatori controllati

• CS9023: L'operatore non può essere verificato
• CS9024: L'operatore non può essere reso non controllato
• CS9025: l'operatore Checked richiede anche la dichiarazione di una versione non controllata corrispondente
• CS9027: parola chiave inaspettata 'unchecked'

Le checked parole chiave e unchecked possono essere applicate solo a dichiarazioni di operatore specifiche. Per le regole complete, vedere Operatori aritmetici e Operatori controllati definiti dall'utente.

• Rimuovere la checked parola chiave o unchecked da un operatore non supportato (CS9023, CS9024). Solo gli operatori aritmetici +, -, *, /, ++, -- e gli operatori di conversione esplicita supportano varianti con e senza controllo. Altri operatori, come gli operatori di confronto o di uguaglianza, non hanno un comportamento distinto in caso di overflow e non possono essere indicati come checked o unchecked.
• Aggiungere una versione corrispondente non verificata dell'operatore (CS9025). Un checked operatore fornisce il comportamento di overflow-throwing, ma il compilatore richiede anche la versione non selezionata corrispondente da usare nei unchecked contesti e come impostazione predefinita quando non viene specificato alcun contesto.
• Rimuovere la unchecked parola chiave dalla posizione non valida (CS9027). La unchecked parola chiave in una dichiarazione di operatore è valida solo come parte della sintassi dell'operatore , ad esempio public static explicit operator unchecked int(MyType t). Inserendolo altrove nella dichiarazione, viene generato un errore di sintassi.

Requisiti di interfaccia e ereditarietà

• CS9311: il tipo non implementa il membro dell'interfaccia. Il tipo non può implementare il membro perché uno di essi non è un operatore
• CS9312: Il tipo non può eseguire l'override del membro ereditato perché uno di essi non è un operatore
• CS9313: L'operatore di assegnazione composta in overload accetta un parametro

Il compilatore applica una rigorosa corrispondenza tra le dichiarazioni degli operatori e i membri dell'interfaccia o i membri della classe di base implementati o sottoposti a override. Per le regole complete, vedere Sovraccarico degli operatori e Interfacce.

• Modificare il membro di implementazione in una dichiarazione di operatore corrispondente al membro dell'operatore dell'interfaccia oppure modificare il membro dell'interfaccia in un metodo se il membro di implementazione è un metodo (CS9311). Un operatore può implementare solo un membro di interfaccia dichiarato anche come operatore, non è possibile soddisfare un contratto di operatore con un metodo regolare o viceversa.
• Modifica il membro sottoposto a override in una dichiarazione di operatore che corrisponde al membro dell'operatore della classe base, o cambia il membro della classe base in un metodo se il membro della classe derivata è un metodo (CS9312). Analogamente all'implementazione dell'interfaccia, un override deve corrispondere al tipo di membro sottoposto a override. Un operatore non può eseguire l'override di un membro non operatore.
• Modificare la dichiarazione dell'operatore di assegnazione composta in modo da accettare esattamente un parametro (CS9313). Gli operatori di assegnazione composta sono membri dell'istanza in cui l'operando sinistro è thisimplicito, quindi solo l'operando di destra viene dichiarato come parametro.

Operatori di uguaglianza

• CS0659: 'class' esegue l'override di Object.Equals(object o) ma non esegue l'override di Object.GetHashCode()
• CS0660: il tipo definisce l'operatore == o l'operatore != ma non esegue l'override di Object.Equals(object o)
• CS0661: il tipo definisce l'operatore == o l'operatore != ma non esegue l'override di Object.GetHashCode()

Il compilatore richiede che le sostituzioni correlate all'uguaglianza e le definizioni degli operatori rimangano sincronizzate. Quando si esegue l'override o si definisce Object.Equalsoperator == / , è necessario specificare anche le sostituzioni operator != correlate. Per le regole complete, vedere Come definire l'uguaglianza dei valori per un tipo e operatori di uguaglianza.

• Aggiungere un override di Object.GetHashCode quando si esegue l'override Object.Equals (CS0659). Le raccolte basate su hash come Dictionary<TKey,TValue> e HashSet<T> si basano sul contratto che due oggetti uguali devono restituire lo stesso codice hash. Senza un override corrispondente GetHashCode , gli oggetti confrontati come uguali potrebbero eseguire l'hashing con bucket diversi, causando errori di ricerca e deduplicazione in modo invisibile all'utente.
• Aggiungere un override di Object.Equals quando si definisce operator == o operator != (CS0660). Il codice che chiama Equals direttamente, incluse molte API del framework, metodi LINQ e operazioni di raccolta, non userà l'operatore personalizzato. Senza un override coerente Equals, gli stessi due oggetti possono essere considerati uguali da == ma non da Equals, causando un comportamento imprevedibile.
• Inserisci un override di Object.GetHashCode quando si definisce operator == o operator != (CS0661). Come CS0659, hai bisogno di GetHashCode mantenere coerenza con la semantica dell'uguaglianza. Se operator == considera due oggetti uguali ma restituiscono codici hash diversi, le raccolte basate su hash non funzioneranno correttamente.

Errori di overflow e underflow

• CS0031: Il valore costante 'value' non può essere convertito in un 'type'
• CS0220: l'operazione genera un overflow in fase di compilazione in modalità controllata
• CS0221: Impossibile convertire il valore costante 'value' in un 'type' (usare la sintassi 'unchecked' per eseguire l'override)
• CS0463: Valutazione dell'espressione costante decimale non riuscita con errore: 'error'
• CS0543: 'enumerazione': il valore dell'enumeratore è troppo grande per adattarsi al tipo
• CS0594: La costante punto mobile è fuori dall'intervallo del tipo 'type'
• CS0652: il confronto con la costante integrale è inutile; la costante non rientra nell'intervallo di tipo 'type'
• CS1021: la costante integrale è troppo grande
• CS8778: il valore costante 'value' può causare un overflow di 'type' durante l'esecuzione (usare la sintassi 'unchecked' per ignorare)
• CS8973: l'operazione può causare overflow durante il tempo di esecuzione (usare la sintassi 'unchecked' per bypassare)

Il compilatore valuta le espressioni costanti in fase di compilazione e segnala errori o avvisi quando un valore supera l'intervallo valido del tipo di destinazione. Per le regole complete, vedere istruzioni controllate e non controllate e tipi integrali.

• Modificare il valore costante in uno che rientra nell'intervallo del tipo di destinazione o modificare la destinazione in un tipo numerico più grande (CS0031). Il compilatore non può restringere in modo implicito una costante che non rientra, ad esempio l'assegnazione 256 a un byte (intervallo da 0 a 255) genera questo errore. Se il troncamento è intenzionale, usare un cast esplicito nel contesto unchecked.
• Correggere l'aritmetica nell'espressione costante in modo che il risultato corrisponda al tipo di destinazione oppure inserire l'espressione in un contesto senza controllo per consentire l'overflow invisibile all'utente (CS0220). Il compilatore valuta l'intera espressione costante in fase di compilazione in un contesto controllato per impostazione predefinita, pertanto i risultati intermedi o finali che superano l'intervallo del tipo causano questo errore.
• Modificare il valore costante o il tipo di destinazione in modo che la conversione sia valida oppure eseguire il wrapping dell'espressione in un unchecked contesto se si desidera intenzionalmente il risultato troncato (CS0221). A differenza di CS0220, questo errore si applica alle conversioni costanti esplicite in cui il valore di origine non rientra nel tipo di destinazione.
• Semplificare o suddividere l'espressione decimal costante in modo che rimanga all'interno dell'intervallo e della precisione del decimal tipo (CS0463). Il decimal tipo ha un valore massimo di circa $7,9 \times 10^{28}$ e 28-29 cifre significative e il compilatore valuta l'espressione completa in fase di compilazione.
• Modificare il valore del membro enum in uno che si adatti al tipo sottostante dell'enum, oppure modificare il tipo sottostante in un tipo integrale più grande (CS0543). Per impostazione predefinita, le enumerazioni usano int come tipo sottostante. Se il valore di un membro supera l'intervallo del tipo sottostante, specificare un tipo più grande, ad esempio long.
• Modificare la costante a virgola mobile in un valore compreso nell'intervallo del tipo di destinazione, oppure utilizzare un tipo con precisione superiore come double invece di float (CS0594). Il float tipo supporta valori fino a circa $3,4 \times 10^{38}$, e double supporta fino a circa $1,7 \times 10^{308}$.
• Rimuovere o correggere il confronto in modo che la costante sia compresa nell'intervallo del tipo della variabile (CS0652). Il confronto di una byte variabile con 300, ad esempio, non può mai essere true, quindi il compilatore avvisa che il confronto è inutile. Questo avviso spesso indica un errore di logica o una mancata corrispondenza tra il tipo di variabile e l'intervallo di valori previsto.
• Usare un tipo numerico più grande o suddividere il valore tra più operazioni (CS1021). Questo errore si verifica quando un valore letterale integer supera l'intervallo del tipo integrale più grande (ulongfino a $1,8 \times 10^{19}$). Per i valori oltre tale intervallo, è consigliabile usare BigInteger.
• Includere l'espressione in un unchecked contesto per eliminare l'avviso o modificare il valore in modo che rientri nell'intervallo del tipo di destinazione (CS8778). Questo avviso indica una conversione costante che potrebbe perdere dati in fase di esecuzione. Il compilatore non può dimostrare che l'overflow si verificherà sicuramente, ma identifica il rischio.
• Racchiudere l'espressione in un unchecked contesto per sopprimere l'avviso, o ristrutturare l'aritmetica per evitare potenziali overflow (CS8973). Questo avviso è simile a CS8778 , ma si applica alle operazioni aritmetiche anziché alle conversioni. Il compilatore rileva che l'operazione potrebbe sovraccaricare in fase di esecuzione.