[Reflection] Opérateurs pour un type donné

Version imprimable

27/11/2006, 16h01
Mose

[Reflection] Opérateurs pour un type donné

Bonjour,

Comment est-il possible, par Reflection, de connaitre les opérateurs acceptés par un Type donné ?

ex :
Int32 défini l'opérateur + et l'opérateur /
DateTime défini l'opérateur + mais pas /
Type ne défini ni + ni /

Mose
29/11/2006, 13h02
Mose

Bon... alors pour trouver les opérateurs, il faut rechercher les méthodes publiques statiques qui ont un nom spécial commençant par op_
ex : op_Addition

J'ai essayé sur quelques types intéressants, et voici mes résultats :
* DateTime : on retrouve bien tous les opérateurs (je pense qu'on peut généraliser pour tous les types références)

* String (ze type référence 'spécial'): on trouve seulement op_Equality et op_Inequality, ça signifie que l'addition(concaténation) est traitée de façon non-objet (ce dont je me doutais un peu vu les optimisations du compilateurs)

* Decimal : on trouve tous les opérateurs, notamment une vingtaine de op_Implicit (cast implicite)

* Tous les types primitifs (int32, double, bool, char, ...): nada, ils n'ont pas d'opérateurs visibles. Les opérations mathématiques ne sont pas gérées de façon objet.

Je vais encore râler contre le framework (vous avez l'habitude ;)), mais visiblement, l'encapsulation objet des types primaires a été baclée.

Bon.. qui est avec moi pour coller un procès à Microsoft qui annonçait le C# comme un langage 100% objet ? :D

Note : Ca m'a permis de découvrir que le type Decimal n'était pas un type primitif, ce qui est un peu curieux étant donné que c'est un type pré-défini dans la grammaire du C#. Ceci dit, il est vrai que ce n'est pas un format de donnée "nativement reconnu" par les processeurs x86.
29/11/2006, 21h19
Mehdi Feki

Citation:

Envoyé par Mose

Je vais encore râler contre le framework (vous avez l'habitude ;)),

Non encore :scarymov:

Donc si tu m'expliquais un peu l'histoire des opératoires et du non-objet parce que je suis un peu perdu.

As-tu reussi à retrouver les opérateurs avec la reflexion ? Un petit code pour nous montrer comment !!!!.

Sinon comment le faire, franchement aucune idée,il faut que je regarde avec plus de détails.

Récupérer le opérateurs sur un Type :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void FindOperators(Type type)
{
  // ce qu'on cherche sont les membres public static
  BindingFlags flags = (BindingFlags.Static | BindingsFlags.Public);
  // plus précisémment des methodes
  MethodInfo[] miz = type.GetMethods(flags);
  // on boucle dessus
  foreach(MethodInfo mi in miz)
  {
    // si le nom est spécial
    if((mi.ISpecialName)
      // et si il commence par "op_"
      && (mi.Name.StartsWith("op_"))
        // alors on a un opérateur
        System.Diagnstics.Debug.WriteLine("opérateur trouvé : "+mi.Name);
  }
}

04/12/2006, 17h56
Mose

Citation:

Envoyé par mehdi_tn

Donc si tu m'expliquais un peu l'histoire des opératoires et du non-objet parce que je suis un peu perdu.

Le code ci dessus ne fonctionne pas pour :
* les types primitifs
* string

On peut en conclure que la gestion de ceux-ci est implémenté directement au niveau du CLR (ça doit être le cas aussi de pas mal d'autre langages). ex : int

A contrario, la résolution des opérateurs par le compilateur pour des objets "standards" nécessite l'implémentation de ces opérateurs dans la classe de cet objet. ex : DateTime

J'en déduit que les types primitifs n'ont pas besoin d'être "boxés" pour qu'on puisse utiliser les opérateurs dessus. Donc leur résolution est à un niveau plus bas que la "couche objet" de .Net.
Avantage : gain en perfs
Inconvénient : ils sont introuvables par Reflection