[.net] Color.FromArgb(Int32)

Souhaitant ne pas m’embêter à convertir mes couleurs au format #RRGGBB, j’ai vu qu’il existant la méthode Color.FromArgb qui prenait en paramètre un Int32 au format 0xAARRGGBB. Je me suis dit, allez, soyons fou, un coup de 0x devant, et j’envoie la sauce.

Première erreur : je pensais que l’opacité complète était codée sur 00, j’ai donc d’abord envoyé Color.FromArgb(0x00849CE7); Résultat obtenu : une couleur transparente, car le canal alpha a son opacité complète sur FF (désolé, je ne fais pas souvent ce genre de truc).

Ok, donc je mets Color.FromArgb(0xFF849CE7).

Blam, je prends un tir : dépassement de capacité pour le type Int32. Ah merde… je regarde Int32.MaxValue : 0x7FFFFFFF. Normal en fait, un Int32 c’est signé. je teste avec unchecked { } juste pour vérifier : ca passe, Color.FromArgb(0xFF849CE7) envoie bien le bleu que je souhaitais obtenir.

J’ai donc un peu de mal à voir la réelle utilité de cette méthode avec ce paramètre (s’il y en a une autre que la possibilité de créer des couleurs semi-transparente avec 1 valeur).

Il n’aurait pas été plus malin de proposer un UInt32 ? (j’anticipe un peu la réponse vu que ce type n’est pas CLS-Compliant)

Si le type est correct, comment est-ce que je suis sensé appeller cette méthode pour qu’elle m’envoie une couleur opaque ? Une opération magique pour pouvoir transformer mon pâté unsigned en Int32 qui signifierai la même chose ?

En attendant j’utiliserai l’autre version avec les 3 paramètres (non je sais, cela ne vas pas m’empêcher de dormir, mais j’ai du mal à piger la raison de cette surcharge).

Moi je vois bien ca :

byte alpha = 255;
byte red = 55;
byte green = 89;
byte blue = 231;

int color = (alpha<<24) + (red << 16) + (green << 8) + blue;

sinon, directement int sValue = (int) uValue; ca marche aussi.

Quand le mets Color myColor = Color.FromArgb((int)0xFF849CE7) il me sort un joli “Constant value ‘value’ cannot be converted to a ‘type’ (use ‘unchecked’ syntax to override)” à la compilation.

J’imagine qu’en passant par une variable je n’aurais pas le problème (à priori il ne pourrait pas détecter le dépassement à la compil dans ce cas).

Exactement :stuck_out_tongue:

Et moi qui pensais avoir trouvé une méthode pour directement utiliser mes valeurs #RRGGBB (en hexa), ben finalement c’est le couac.

Edit : effectivement ca passe

uint colorCode = 0xFFFF9484; Color mycolor = Color.FromArgb((int)colorCode);
My god, it’s moche.

ma premiere suggestion en séparant chaque composante me parait effectivement plus jolie… en plus c’est pratique si tu veux créer un color picker ou autre truc dans le genre

Ouaip, enfin en l’occurence, j’avais un tas de couleurs en chaine sous la forme RRGGBB et je souhaitais remplir une liste de color, d’où mon engouement pour cette méthode : j’aurais pu initialiser ma couleur en 1 ligne. Avec 3 variables bytes, multiplié par une vingtaine de couleurs…

M’enfin, j’aurais plutôt aimé connaître la raison, s’il y en avait une, d’un tel paramètre, au lieu d’un long par exemple. (C’est mal, j’ai regardé avec reflector, et j’ai vu qu’ils utilisaient un long derrière).

Interop win32 :stuck_out_tongue: