J'ai donc du code en VB que j'essaye de convertir en C #. Ce code a été écrit par quelqu'un d'autre et j'essaie de le comprendre mais avec quelques difficultés. J'ai un opérateur binaire et une comparaison d'énumérations à faire, mais continuez à lancer une erreur:
Je ne peux pas dire que j'ai utilisé beaucoup de ces syntaxes auparavant et je ne sais pas comment écrire ce code. J'ai utilisé Google pour en savoir plus et j'ai également utilisé des convertisseurs en ligne VB vers C # dans l'espoir d'obtenir des conseils de base, mais rien. Le code ci-dessous
VB - Ceci est le code original qui fonctionne
Flags = Flags & !MyEnum.Value; // Flags is of type int
C # - le code que j'ai converti qui génère une erreur
Flags = Flags And Not MyEnum.Value ' Flags is of type int
Erreur - L'erreur qui est renvoyée à chaque fois
Opérateur '!' ne peut pas être appliqué à l'opérande de type MyEnum '.
Toute aide et quelques explications à ce sujet seront grandement appréciées.
3 Réponses :
Vous confondez peut-être les opérateurs unaires Logique et Bitwise
Permet de visiter l'aide
Opérateurs (Guide de programmation C # )
Opérateurs unaires
+ x Identité -x Négation ! x Négation logique ~ x Négation au niveau du bit ++ x Pré-incrémentation --x Pré-décrémentation (T) x Convertit explicitement x en type T L'opérateur 'opérateur' ne peut pas être appliqué à l'opérande de type 'type'
Une tentative a été faite pour appliquer un opérateur à une variable dont le type était non conçu pour fonctionner avec l'opérateur.
! ne peut fonctionner que sur le type bool . Vous semblez utiliser certains indicateurs de bits. Dans ce cas, vous devez utiliser l'opérateur NOT au niveau du bit ~ au lieu de l'opérateur NOT logique !:
Flags = Flags & ~((int)MyEnum.Value); // you need to cast to int as well
Vous aurez besoin d'un cast de la valeur enum en un int.
@DaveDoknjas pourquoi dites-vous cela? Je crois que ce n'est pas vrai, car le type sous-jacent de l'énumération serait un int et donc l'opérateur ~ fonctionne très bien sans casting.
@KirkWoll: L'opérateur binaire '&' n'est pas défini pour int et aucune énumération (c'est l'erreur réelle que vous obtiendrez), vous devez donc effectuer un cast.
@DaveDoknjas ne sais pas de quoi vous parlez. Cela fonctionne parfaitement bien: var foo = Foo.A | Foo.B; foo = foo & ~ Foo.A; Où Foo est déclaré comme un enum .
De plus, de cours & est défini pour int . int i = 0 & 5; est parfaitement valide.
@KirkWoll Dave Doknjas a raison. Toutes les énumérations ont un opérateur ~ qui renvoie une énumération, mais la résolution de surcharge pour & échoue lorsque vous avez un int et un MyEnum < / code>. Lisez la section 7.5.3 des spécifications de langue.
@Sweeper, comme je l'ai dit, foo = foo & ~ Foo.A fonctionne parfaitement bien. Est-ce que je manque quelque chose?
@KirkWoll: Dans votre exemple, "foo" n'est pas un int comme dans l'exemple de Sweeper - vous remarquerez que son type est "Foo". Si vous changez "foo" pour qu'il soit de type int, vous verrez le problème. Dans l'exemple de Sweeper, "Flags" est de type int.
Ah merci! Vous avez tous les deux raison. Mais cela laisse la question de savoir pourquoi Flags n'est pas déclaré comme le type enum réel dans ce cas où rien de tout cela ne serait nécessaire.
Pour obtenir la meilleure conversion, il est utile de comprendre d'abord la conversion implicite que VB effectue pour vous:
Flags &= ~(int)MyEnum.Value;
Ceci est équivalent au code C #:
Flags = Flags & ~(int)MyEnum.Value;
Ce qui peut être raccourci:
Flags = Flags And Not (CInt(MyEnum.Value))
En VB, "Not" est à la fois l'opérateur logique et bit à bit, selon le contexte, mais en C # vous ont deux opérateurs distincts.
!n'est pas un opérateur au niveau du bit, vous vouliez probablement dire~