Résoudre les erreurs et les avertissements pour les déclarations d’opérateur et le dépassement de capacité

Cet article traite des erreurs et des avertissements suivants du compilateur :

CS0031 : La valeur constante 'value' ne peut pas être convertie en 'type'
CS0056 : Accessibilité non cohérente : le type de retour 'type' est moins accessible que l'opérateur 'operator'
CS0057 : Accessibilité incohérente : le type de paramètre 'type' est moins accessible que l’opérateur 'operator'
CS0215 : Le type de retour de l’opérateur True ou False doit être bool
CS0216 : L’opérateur 'operator' nécessite qu’un opérateur correspondant 'missing_operator' soit également défini
CS0217 : Pour être applicable en tant qu’opérateur de court-circuit, un opérateur logique défini par l’utilisateur ('opérateur') doit avoir le même type de retour que le type de ses 2 paramètres.
CS0218 : Le type ('type') doit contenir des déclarations d’opérateur true et d’opérateur false
CS0220 : L’opération provoque un débordement au moment de la compilation en mode vérifié
CS0221 : La valeur constante 'value' ne peut pas être convertie en 'type' (utilisez la syntaxe 'unchecked' pour remplacer)
CS0448 : Le type de retour pour l'opérateur ++ ou -- doit être le type contenant ou dérivé du type contenant
CS0463 : Échec de l’évaluation de l’expression constante décimale avec l’erreur « error »
CS0543 : 'énumération' : la valeur d’énumérateur est trop grande pour s’adapter à son type
CS0552 : « routine de conversion » : conversion définie par l’utilisateur vers/depuis l’interface
CS0553 : « routine de conversion » : conversion définie par l’utilisateur vers/depuis la classe de base
CS0554 : 'routine de conversion' : conversion définie par l’utilisateur vers/à partir de la classe dérivée
CS0555 : L’opérateur défini par l’utilisateur ne peut pas prendre un objet du type englobant et le convertir en objet du type englobant
CS0556 : La conversion définie par l’utilisateur doit être convertie en ou depuis le type englobant
CS0557 : Duplication de conversion définie par l’utilisateur dans le type
CS0558 : L’opérateur défini par l’utilisateur doit être déclaré statique et public
CS0559 : Le type de paramètre pour ++ ou -- l’opérateur doit être le type conteneur
CS0562 : Le paramètre d’un opérateur unaire doit être le type conteneur
CS0563 : L’un des paramètres d’un opérateur binaire doit être le type conteneur
CS0564 : Le premier opérande d’un opérateur de décalage surchargé doit avoir le même type que le type contenant, et le type du deuxième opérande doit être int
CS0567 : Les interfaces ne peuvent pas contenir d’opérateurs
CS0590 : Les opérateurs définis par l’utilisateur ne peuvent pas retourner void
CS0594 : La constante à virgule flottante est en dehors de la plage du type 'type'
CS0652 : La comparaison à la constante intégrale est inutile ; la constante est en dehors de la plage de type 'type'
CS0659 : 'class' remplace Object.Equals(object o) mais ne remplace pas Object.GetHashCode()
CS0660 : Le type définit operator == ou operator != ne remplace Object.Equals(object o)pas
CS0661 : Le type définit operator == ou operator != ne remplace Object.GetHashCode()pas
CS0715 : Les classes statiques ne peuvent pas contenir d’opérateurs définis par l’utilisateur
CS1021 : Constante intégrale est trop grande
CS1037 : Opérateur surchargé attendu
CS1553 : La déclaration n’est pas valide ; utilisez l’opérateur <de modification dest-type> (...' au lieu de
CS8930 : L’implémentation explicite d’un opérateur défini par l’utilisateur doit être déclarée statique
CS8931 : Une conversion définie par l'utilisateur dans une interface doit consister en une conversion vers ou à partir d'un paramètre de type sur le type englobant restreint au type englobant
CS8778 : La valeur constante 'value' peut dépasser 'type' au moment de l’exécution (utilisez la syntaxe 'unchecked' pour remplacer)
CS8973 : L’opération peut entraîner un débordement au moment de l’exécution (utilisez la syntaxe « non vérifié » pour contourner)
CS9023 : L’opérateur ne peut pas être vérifié.
CS9024 : L’opérateur ne peut pas être désactivé.
CS9025 : L’opérateur nécessite qu’une version non vérifiée correspondante soit également déclarée.
CS9027 : mot clé inattendu « désactivé ».
CS9308 : l’opérateur défini par l’utilisateur doit être déclaré public.
CS9310 : Le type de retour de cet opérateur doit être void.
CS9311 : Le type n’implémente pas le membre de l’interface. Le type ne peut pas implémenter le membre, car l’un d’eux n’est pas un opérateur.
CS9312 : Le type ne peut pas remplacer le membre hérité, car l’un d’eux n’est pas un opérateur.
CS9313 : Un opérateur d'affectation composée surchargé prend un paramètre.
CS9340 : L’opérateur ne peut pas être appliqué aux opérandes. Le candidat inapplicable le plus proche est affiché.
CS9341 : L’opérateur ne peut pas être appliqué à l’opérande. Le candidat inapplicable le plus proche est affiché.
CS9342 : La résolution d’opérateur est ambiguë entre les membres suivants.

Exigences relatives à la signature de l’opérateur

CS0448: Le type de retour pour l’opérateur ++ ou -- doit être le type conteneur ou dérivé du type conteneur.
CS0559 : le type de paramètre pour ++ ou -- l’opérateur doit être le type conteneur.
CS0562 : Le paramètre d’un opérateur unaire doit être le type conteneur.
CS0563 : l’un des paramètres d’un opérateur binaire doit être le type conteneur.
CS0564 : Le premier opérande d’un opérateur de décalage surchargé doit avoir le même type que le type conteneur, et le type du deuxième opérande doit être int.
CS0567 : Les interfaces ne peuvent pas contenir d’opérateurs.
CS0590 : Les opérateurs définis par l’utilisateur ne peuvent pas retourner "void".
CS9310 : Le type de retour de cet opérateur doit être void.
CS9340 : L’opérateur ne peut pas être appliqué aux opérandes. Le candidat inapplicable le plus proche est affiché.
CS9341 : L’opérateur ne peut pas être appliqué à l’opérande. Le candidat inapplicable le plus proche est affiché.
CS9342 : La résolution d’opérateur est ambiguë entre les membres suivants.

Chaque type d’opérateur a des exigences de paramètre et de retour spécifiques définies par la spécification du langage. Pour connaître les règles complètes concernant la surcharge des opérateurs, consultez les sections Surcharge des opérateurs et Opérateurs dans la spécification C#.

Changez le type de retour des opérateurs ++ ou -- en le type conteneur ou un type dérivé de celui-ci (CS0448). La langue nécessite que les opérateurs d’incrémentation et de décrémentation retournent une valeur compatible avec le type conteneur afin que le résultat puisse être affecté à la même variable.
Remplacez le paramètre des opérateurs ++ ou -- par le type de conteneur (CS0559). Les opérateurs d’incrémentation et de décrémentation doivent fonctionner sur des instances de leur propre type.
Remplacez le paramètre d’un opérateur unaire par le type conteneur (CS0562). Les opérateurs unaires doivent accepter un opérande du type qui les déclare.
Vérifiez qu’au moins un paramètre d’un opérateur binaire est le type conteneur (CS0563). Les opérateurs binaires doivent impliquer le type déclarant afin que le compilateur puisse les résoudre via ce type.
Remplacez le premier paramètre d’un opérateur shift par le type conteneur et le deuxième paramètre int par (CS0564). Le langage définit les opérateurs de décalage avec une signature spécifique : le type en cours de décalage et une quantité de décalage entière.
Déplacer les déclarations d’opérateur hors des interfaces et dans des classes ou des structs (CS0567). Les déclarations d’opérateur traditionnelles (abstraite non statique) ne sont pas autorisées dans les interfaces. Pour les opérateurs abstraits statiques dans les interfaces, consultez les erreurs de membre d’interface abstraite statique et d’interface virtuelle.
Remplacez le type de retour de l’opérateur par un type autre que void (CS0590). La plupart des opérateurs définis par l’utilisateur doivent retourner une valeur. L’exception est des opérateurs d’affectation composée, qui nécessitent un void type de retour (CS9310).
Corrigez les types de paramètres ou ajoutez des surcharges d’opérateur manquantes afin que le compilateur puisse trouver un opérateur correspondant pour les types d’opérandes utilisés sur le site d’appel (CS9340, CS9341). Lorsqu’aucun opérateur applicable n’existe, le compilateur affiche le candidat le plus proche pour diagnostiquer l’incompatibilité.
Ajoutez des casts explicites sur le site d’appel ou fournissez des surcharges plus spécifiques pour éliminer l’ambiguïté lorsque plusieurs surcharges d’opérateur correspondent également bien (CS9342).

Important

Les exigences de signature pour les opérateurs binaires statiques et les opérateurs d’assignation composée d’instances correspondantes sont différentes. Vérifiez que la signature correspond à la déclaration souhaitée.

Exigences de déclaration d’opérateur

CS0558 : l’opérateur défini par l’utilisateur doit être déclaré statique et public.
CS0715 : Les classes statiques ne peuvent pas contenir d’opérateurs définis par l’utilisateur.
CS1037 : opérateur surchargé attendu.
CS1553 : La déclaration n’est pas valide ; utilisez l’opérateur <modificateur dest-type> (...' au lieu de.
CS9308 : l’opérateur défini par l’utilisateur doit être déclaré public.

Le langage nécessite des modificateurs et une syntaxe spécifiques pour les déclarations d’opérateur. Pour connaître les règles complètes, consultez surcharge des opérateurs et opérateurs de conversion définis par l'utilisateur.

Ajoutez à la fois les modificateurs static et public à la déclaration d'opérateur (CS0558, CS9308). Le langage C# nécessite que tous les opérateurs définis par l’utilisateur soient statiques et publics afin qu’ils soient accessibles et appelants sans instance.
Déplacez la déclaration d’opérateur d’une classe statique vers une classe ou un struct non statique (CS0715). Les classes statiques ne peuvent pas avoir d’instances, de sorte que les opérateurs définis par l’utilisateur, qui opèrent sur des instances de leur type conteneur, ne sont pas significatifs dans les classes statiques.
Remplacez le symbole d’opérateur non valide par un opérateur surchargé valide (CS1037). Seuls les opérateurs spécifiques définis par la langue peuvent être surchargés.
Corrigez la syntaxe pour suivre le formulaire d’opérateur de conversion requis : public static implicit operator <dest-type>(<source-type> parameter) ou public static explicit operator <dest-type>(<source-type> parameter) (CS1553). Le compilateur s’attend à ce que les opérateurs de conversion suivent un modèle de déclaration spécifique.

Pour connaître les erreurs liées aux implémentations d’interface explicites d’opérateurs dans des interfaces abstraites statiques, consultez les erreurs de membre de l’interface abstraite statique et d’interface virtuelle.

Accessibilité incohérente

CS0056 : Accessibilité incohérente : le type de retour 'type' est moins accessible que l’opérateur 'operator'.
CS0057 : Accessibilité incohérente : le type de paramètre 'type' est moins accessible que l’opérateur 'operator'.

Tous les types utilisés dans la signature d’un opérateur public doivent être au moins aussi accessibles que l’opérateur lui-même. Pour connaître les règles complètes, consultez Les modificateurs d’accès et les contraintes d’accessibilité dans la spécification C#.

Remplacez le type de retour par un type qui est au moins aussi accessible que l’opérateur, ou réduisez l’accessibilité de l’opérateur pour qu’il corresponde au type de retour (CS0056). Un public opérateur ne peut pas exposer un type moins accessible par le biais de sa valeur de retour, car les appelants en dehors de l’assembly ne peuvent pas utiliser le résultat.
Remplacez le type de paramètre par un type qui est au moins aussi accessible que l’opérateur, ou réduisez l’accessibilité de l’opérateur pour qu’il corresponde au type de paramètre (CS0057). Un public opérateur ne peut pas exiger un type moins accessible en tant que paramètre, car les appelants en dehors de l’assembly ne peuvent pas fournir l’argument.

Restrictions de conversion définies par l’utilisateur

CS0552 : Conversion définie par l’utilisateur vers/depuis l’interface.
CS0553 : conversion définie par l’utilisateur vers/depuis la classe de base.
CS0554 : conversion personnalisée vers et depuis une classe dérivée.
CS0555 : L’opérateur défini par l’utilisateur ne peut pas prendre un objet du type englobant et le convertir en objet du type englobant.
CS0556 : La conversion définie par l’utilisateur doit se faire depuis ou vers le type englobant.
CS0557 : Double conversion définie par l'utilisateur dans le type.

Le langage C# limite les types qui peuvent participer aux conversions définies par l’utilisateur. Pour connaître les règles complètes, consultez les opérateurs de conversion définis par l’utilisateur et les opérateurs de conversion dans la spécification C#.

Supprimez l’opérateur de conversion qui convertit en ou à partir d’un type d’interface (CS0552). Le langage interdit les conversions définies par l’utilisateur impliquant des types d’interface, car les conversions d’interface sont gérées via les conversions de référence et la boxe du système de types. Utilisez plutôt des implémentations d’interface explicites ou des méthodes d’assistance.
Supprimez l’opérateur de conversion qui convertit en ou à partir d’une classe de base (CS0553). Les conversions entre un type et sa classe de base existent déjà via des conversions de référence implicites (upcast) et des conversions de référence explicites (downcast), afin qu’une conversion définie par l’utilisateur crée une ambiguïté.
Supprimez l’opérateur de conversion qui convertit en ou à partir d’une classe dérivée (CS0554). Comme les conversions de classes de base, les conversions entre un type et ses types dérivés sont intégrées au langage via l’héritage, et les conversions définies par l’utilisateur sont en conflit avec eux.
Supprimez l’opérateur de conversion qui convertit le type englobant en lui-même (CS0555). Chaque type a déjà une conversion d’identité implicite vers lui-même. Par conséquent, une conversion définie par l’utilisateur d’un type vers le même type est redondante et n’est pas autorisée.
Modifiez l’un des types dans l’opérateur de conversion afin que le type source ou de destination soit le type englobant (CS0556). Une conversion définie par l’utilisateur doit impliquer le type qui le déclare : vous ne pouvez pas définir une conversion entre deux types externes non liés dans un troisième type.
Supprimez l’opérateur de conversion en double ou modifiez l’un des opérateurs en double afin que les types source et de destination diffèrent de l’autre (CS0557). Un type ne peut déclarer qu’une seule conversion implicite et une conversion explicite pour une paire donnée de types source et de destination.

Opérateurs booléens et opérateurs de court-circuit

CS0215 : Le type de retour de l’opérateur true ou false doit être bool.
CS0216 : L’opérateur nécessite qu’un opérateur correspondant soit également défini.
CS0217 : Pour être applicable en tant qu’opérateur court-circuit, un opérateur logique défini par l’utilisateur doit avoir le même type de retour que le type de ses 2 paramètres.
CS0218 : Le type doit contenir des déclarations d’opérateur true et d’opérateur false.

Le langage C# nécessite des paires et des signatures spécifiques pour les opérateurs booléens et l’évaluation de court-circuit. Pour connaître les règles complètes, consultez les opérateurs vrais et faux, les opérateurs logiques booléens et les opérateurs logiques conditionnels définis par l’utilisateur dans la spécification C#.

Modifiez le type de retour de operator true et operator false vers bool (CS0215). Ces opérateurs déterminent si une valeur est logiquement vraie ou false, de sorte que la langue les oblige à retourner bool.
Définissez l’opérateur jumelé correspondant (CS0216). La langue exige que certains opérateurs soient déclarés en paires : operator == avec operator !=, operator < avec operator >, avec , operator <= avec operator >=, et operator true avec operator false.
Modifiez le type de retour de l'opérateur défini par l'utilisateur & ou | pour qu'il soit compatible avec les deux types de paramètres (CS0217). Pour l’évaluation en court-circuit (&& et ||), le compilateur exige que le type de retour de l’opérateur & ou |, les deux types de paramètres, et le type conteneur soient tous du même type.
Ajoutez les deux déclarations operator true et operator false au type (CS0218). Le compilateur réécrit && et || en utilisant operator true, operator false, et l’opérateur correspondant & ou |, donc ces trois éléments doivent être présents pour que l’évaluation de court-circuit fonctionne.

Opérateurs vérifiés

CS9023 : L’opérateur ne peut pas être vérifié
CS9024 : L’opérateur ne peut pas être défini comme non vérifié
CS9025 : L’opérateur Checked nécessite une version non vérifiée correspondante pour être également déclarée
CS9027 : mot clé inattendu « désactivé »

Les mots clés checked et unchecked ne peuvent être appliqués qu’à des déclarations d’opérateur spécifiques. Pour connaître les règles complètes, consultez les opérateurs arithmétiques et les opérateurs vérifiés définis par l’utilisateur.

Supprimez le mot-clé checked ou unchecked d’un opérateur non pris en charge (CS9023, CS9024). Seuls les opérateurs arithmétiques +, -, *, /, ++, -- et les opérateurs de conversion explicites prennent en charge les variantes 'checked' et 'unchecked'. D’autres opérateurs, tels que des opérateurs de comparaison ou d’égalité, n’ont pas de comportement de dépassement distinct et ne peuvent pas être marqués comme activés ou désactivés.
Ajoutez une version non vérifiée correspondante de l’opérateur (CS9025). Un checked opérateur fournit le comportement de dépassement de capacité, mais le compilateur a également besoin de la version non vérifiée correspondante à utiliser dans unchecked les contextes et comme valeur par défaut quand aucun contexte n’est spécifié.
Supprimez le unchecked mot clé de la position non valide (CS9027). Le unchecked mot clé d’une déclaration d’opérateur n’est valide que dans le cadre de la syntaxe de l’opérateur (par exemple). public static explicit operator unchecked int(MyType t) Le fait de le placer ailleurs dans la déclaration provoque une erreur de syntaxe.

Exigences relatives à l’interface et à l’héritage

CS9311 : Le type n’implémente pas le membre de l’interface. Le type ne peut pas implémenter le membre, car l’un d’eux n’est pas un opérateur
CS9312 : Le type ne peut pas remplacer le membre hérité, car l’un d’eux n’est pas un opérateur
CS9313 : L’opérateur d'affectation composé surchargé prend un paramètre

Le compilateur applique une correspondance stricte entre les déclarations d’opérateur et les membres de l’interface ou les membres de classe de base qu’ils implémentent ou remplacent. Pour connaître les règles complètes, consultez Surcharge des opérateurs et interfaces.

Remplacez le membre d’implémentation par une déclaration d’opérateur qui correspond au membre d’opérateur de l’interface, ou remplacez le membre d’interface par une méthode si le membre d’implémentation est une méthode (CS9311). Un opérateur ne peut implémenter qu’un membre d’interface qui est également déclaré en tant qu’opérateur , vous ne pouvez pas satisfaire un contrat d’opérateur avec une méthode régulière, ou inversement.
Remplacez le membre substitué par une déclaration d’opérateur qui correspond au membre d’opérateur de la classe de base ou remplacez le membre de classe de base par une méthode si le membre de classe dérivé est une méthode (CS9312). Comme pour l'implémentation de l'interface, une redéfinition doit correspondre au type de membre redéfini. Un opérateur ne peut pas redéfinir un membre qui n'est pas un opérateur.
Modifiez la déclaration d’opérateur d’affectation composée pour accepter exactement un paramètre (CS9313). Les opérateurs d’affectation composée sont des membres d’instance où l’opérande gauche est implicitement this, de sorte que seul l’opérande de droite est déclaré en tant que paramètre.

Opérateurs d'égalité

CS0659 : 'class' remplace Object.Equals(object o) mais ne remplace pas Object.GetHashCode()
CS0660 : Type définit l’opérateur == ou l’opérateur != mais ne remplace pas Object.Equals(object o)
CS0661 : Type définit l’opérateur == ou l’opérateur != mais ne remplace pas Object.GetHashCode()

Le compilateur exige que les remplacements liés à l’égalité et les définitions d’opérateur restent synchronisés. Lorsque vous remplacez Object.Equals ou définissez operator == / operator !=, vous devez également fournir les remplacements associés. Pour connaître les règles complètes, consultez Comment définir l’égalité des valeurs pour un type et des opérateurs d’égalité.

Ajoutez une substitution de Object.GetHashCode lorsque vous remplacez Object.Equals (CS0659). Les collections basées sur le hachage comme Dictionary<TKey,TValue> et HashSet<T> s’appuient sur le contrat que deux objets égaux doivent retourner le même code de hachage. Sans remplacement correspondant GetHashCode, les objets qui sont considérés comme égaux peuvent avoir des valeurs de hachage différentes, provoquant l'échec silencieux des recherches et de la déduplication.
Ajoutez une redéfinition de Object.Equals lorsque vous définissez operator == ou operator != (CS0660). Le code qui appelle Equals directement, y compris de nombreuses API d’infrastructure, méthodes LINQ et opérations de collecte, n’utilise pas votre opérateur personnalisé. Sans une substitution cohérente Equals, les deux mêmes objets peuvent être considérés comme égaux par ==, mais pas par Equals, ce qui entraîne un comportement imprévisible.
Ajoutez une substitution de Object.GetHashCode lorsque vous définissez operator == ou operator != (CS0661). Comme CS0659, vous devez GetHashCode être cohérent avec votre sémantique d’égalité. Si operator == considère que deux objets sont égaux mais qu'ils retournent des codes de hachage différents, les collections basées sur le hachage ne fonctionneront pas correctement.

Erreurs de dépassement de capacité et de sous-flux

CS0031 : La valeur constante 'value' ne peut pas être convertie en 'type'
CS0220 : Un dépassement est détecté à la compilation en mode vérifié
CS0221 : La valeur constante 'value' ne peut pas être convertie en 'type' (utilisez la syntaxe 'unchecked' pour remplacer)
CS0463 : Échec de l’évaluation de l’expression constante décimale avec l’erreur « erreur »
CS0543 : 'énumération' : la valeur d’énumérateur est trop grande pour s’adapter à son type
CS0594: La constante à virgule flottante est en dehors de la plage du type 'type'
CS0652 : La comparaison à la constante intégrale est inutile ; la constante est en dehors de la plage de type 'type'
CS1021 : Constante intégrale est trop grande
CS8778 : La valeur constante 'value' peut dépasser 'type' au moment de l’exécution (utilisez la syntaxe 'unchecked' pour remplacer)
CS8973 : L’opération peut entraîner un débordement à l'exécution (utilisez la syntaxe 'unchecked' pour passer outre)

Le compilateur évalue les expressions constantes au moment de la compilation et signale des erreurs ou des avertissements lorsqu’une valeur dépasse la plage valide de son type cible. Pour connaître les règles complètes, consultez les instructions cochées et désactivées et les types intégraux.

Modifiez la valeur constante en une valeur qui correspond à la plage du type cible ou remplacez la cible par un type numérique plus grand (CS0031). Le compilateur ne peut pas limiter implicitement une constante qui ne convient pas, par exemple, l’affectation 256 à une byte (plage 0 à 255) génère cette erreur. Si la troncation est intentionnelle, utilisez un cast explicite dans un unchecked contexte.
Corrigez l’arithmétique dans l’expression constante afin que le résultat corresponde au type cible, ou encapsulez l’expression dans un contexte non vérifié pour autoriser le dépassement silencieux (CS0220). Le compilateur évalue l’expression constante entière au moment de la compilation dans un contexte vérifié par défaut, de sorte que les résultats intermédiaires ou finaux qui dépassent la plage du type provoquent cette erreur.
Modifiez la valeur constante ou le type cible afin que la conversion soit valide, ou encapsulez l’expression dans un unchecked contexte si vous souhaitez intentionnellement le résultat tronqué (CS0221). Contrairement à CS0220, cette erreur s’applique aux conversions de constantes explicites où la valeur source ne correspond pas au type de destination.
Simplifiez ou séparez l’expression decimal constante afin qu’elle reste dans la plage et la précision du decimal type (CS0463). Le decimal type a une valeur maximale d’environ $7.9 \times 10^{28}$ et 28-29 chiffres significatifs, et le compilateur évalue l’expression complète au moment de la compilation.
Modifiez la valeur de membre d’énumération en une valeur qui correspond au type sous-jacent de l’énumération, ou remplacez le type sous-jacent par un type intégral plus grand (CS0543). Par défaut, les énumérations utilisent int comme type sous-jacent. Si la valeur d’un membre dépasse la plage du type sous-jacent, spécifiez un type plus grand comme long.
Remplacez la constante à virgule flottante par une valeur dans la plage du type cible, ou utilisez un type de précision plus élevé comme double au lieu de float (CS0594). Le float type prend en charge les valeurs jusqu’à environ 3,4 $ \fois 10^{38}$, et double prend en charge jusqu’à environ 1,7 $ \fois 10^{308}$.
Supprimez ou corrigez la comparaison afin que la constante se trouve dans la plage du type de la variable (CS0652). La comparaison d’une byte variable à 300, par exemple, ne peut jamais être vraie, de sorte que le compilateur avertit que la comparaison est inutile. Cet avertissement indique souvent une erreur logique ou une incompatibilité entre le type de variable et la plage de valeurs prévue.
Utilisez un type numérique plus grand ou fractionnez la valeur entre plusieurs opérations (CS1021). Cette erreur se produit lorsqu’un littéral entier dépasse la plage du type intégral le plus grand (ulongjusqu’à 1,8 $ \fois 10^{19}$). Pour les valeurs au-delà de cette plage, envisagez d’utiliser BigInteger.
Encapsulez l’expression dans un unchecked contexte pour supprimer l’avertissement ou modifiez la valeur en fonction de la plage du type cible (CS8778). Cet avertissement indique une conversion constante qui peut perdre des données au moment de l’exécution. Le compilateur ne peut pas prouver que le dépassement de capacité se produit certainement, mais il identifie le risque.
Encapsulez l'expression dans un unchecked contexte afin de supprimer cet avertissement, ou restructurez l’arithmétique afin d’éviter le débordement potentiel (CS8973). Cet avertissement est similaire à CS8778 , mais s’applique aux opérations arithmétiques plutôt qu’aux conversions , le compilateur détecte que l’opération peut dépasser au moment de l’exécution.

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-26