7
votes

Casting Enum à Uint

J'écris une fonction qui prend un Enum code> et le jette à uint code>. D'après ce que j'ai vu lors de la coulée sur int code>, vous devez la jeter à un objet d'abord: (int) (objet) myeuMumValue code>. Si vous écrivez (int) myEnumValue code> Vous obtenez une exception de temps de compilation.

Maintenant, quand j'ai essayé de le jeter à Uint, je m'attendais à ce que (uint) (objet) myeuMumvalue code> serait d'accord. Il compile bien, mais lorsqu'il est exécuté, il génère un invalidalcastexception code>. Donc, pour le faire fonctionner, j'ai utilisé p> xxx pré>

Je pense que ça a l'air drôle, alors je suis assez heureux, mais pourquoi? P> Peut-être qu'il aurait été plus correct de demander pourquoi il n'est pas possible de lancer objet code> à uint code>, mais je suis intéressé s'il y a une autre façon d'aller de un Enum code> à uint code>. Est-ce là? P>

edit: b> p>

Le contexte est une fonction, quelque chose comme ceci: p> xxx pré>

EDIT 2: B> P>

La meilleure solution a été aussi mentionnée par TheCoop: P>

Convert.ToUInt32(e)

c# enums

0 commentaires

3 Réponses :

15
votes

L'approche (uint) (uint) (objet) (objet) échoue car, par défaut, c # Enums utilise int comme type sous-jacent et un int Est ce qu'ils sont transformés en morceaux quand ils sont en boîte. La syntaxe C # donne l'impression d'imlevés hériter de leur type sous-jacent (comme Enum myenum: uint ).

Vous devez expliquer explicitement le compilateur à UNBOX à partir de objet à int d'abord, puis effectuez une conversion numérique de int sur vers uint . (Même si la syntaxe est la même, la boîte de séjour à partir de objet à un type de valeur est un processus différent de la coulée entre int et uint .) < / p>



                                                                    
                                    
                                    
                                        6 commentaires
                                        
                                                                                            
                                                    Ok, donc si je spécifie mon énumé comme Enum: Uint, ce serait l'inverse?                                                
                                                
                                                                                            
                                                    @Jonatan: Oui, cela enregistrerait l'énumé comme Uint, et vous seriez obligé de non BOX comme Uint.                                                
                                                
                                                                                            
                                                    C'est vrai: (uint) e ira bien, mais (int) e va exploser.                                                
                                                
                                                                                            
                                                    @IM: hérit est un mauvais terme. Vous ne pouvez pas hériter de  system.int32  (peut-être que vous pouvez avec une magie blanche vaudou, mais ce n'est pas pertinent). Enums hériter de  system.enum . Ce qui est correct de dire, c'est que le type sous-jacent est  int .                                                

                                                
                                                                                            
                                                    Euh, tu as raison. Et dans cette situation, ce qui compte, c'est que l'énumé est en boîte à un INT.                                                
                                                
                                                                                            
                                                    @Cethecoop, oui, et cela pourrait être le seul moyen pratique si vous n'êtes pas sûr de savoir si vous avez affaire à un INT ou à un UINT. Ajoutez votre propre réponse et je vais vous uppoter :)


                        
                                            
                            
                                
                                    5
 votes
                                
                            
                            
                                
                                    
   De ce que j'ai vu lors de la coulée to int, vous devez la jeter à un objet d'abord:  (int) (objet) myenum  code>. Si vous écrivez  (int) myenum  code> vous obtenez une exception de temps de compilation.  P>
 pas vrai. Vous pouvez directement lancer une valeur ENUM à un type d'entier.  P> 

   Maintenant, quand j'ai essayé de le jeter à Uint, je m'attendais à ce que (uint) (objet) myenum serait bien. Il compile bien, mais lorsqu'il est exécuté, il génère une introduction invalide. Donc, pour le faire fonctionner, j'ai utilisé:
          (uint) (int) (objet) myenum  code> 

  Je pense que ça a l'air drôle, alors je suis assez heureux, mais pourquoi est-ce tellement?  P>
 blockQuote> 
 Lorsque vous lancez une valeur ENUM sur  objet  code>, il sera en boîte comme son  type sous-jacent  em>, qui est  int  code> par défaut. Vous ne pouvez pas créer une valeur de boîte à une boîte à un type autre que son type réel directement. Même cela échouera:  P> 
short s = 10;
object o = s;
int i = (int)o; // throws `InvalidCastException` while `int i = (int)s;` works.

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Si vous auriez besoin d'aller dans la direction opposée, c'est-à-dire d'un type sous-jacent à l'énumération d'un type particulier:  xxx  
 J'ai trouvé cela nécessaire (plutôt que simple casting) lors de la création de types génériques. Puisque vous ne pouvez pas utiliser "où" clauses pour contraindre suffisamment le type générique  à votre type d'énumération, le compilateur ne vous permettra pas de lancer un numérique.                                  

                                                                    
                                    
                                    
                                        0 commentaires