Discussion :

[Mose]

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

[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 ?

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.

[Mehdi Feki]

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

Non encore

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.

[Mose]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
  }
}

[Mose]

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