Utiliserait double.TryParse, il a des avantages en termes de performances.

J'utiliserais personnellement int.tryparse, puis double.tryparse. Les performances de ces méthodes sont assez rapides. Ils renvoient tous les deux un booléen. Si les deux échouent, vous avez une chaîne, selon la façon dont vous avez défini vos données.

Je dirais qu'il ne faut pas trop s'inquiéter de ces micro-performances. Il est préférable de faire fonctionner quelque chose, puis de le rendre aussi clair, concis et facile à lire que possible. La pire chose que vous puissiez faire est de sacrifier la lisibilité pour une quantité insignifiante de performances.

En fin de compte, la meilleure façon de gérer les problèmes de performances est de les enregistrer lorsque vous avez des données qui indiquent qu'il y a un problème de performances réel... sinon vous passerez beaucoup de temps à micro-optimiser et provoquerez en fait une augmentation coûts de maintenance pour plus tard.

Si vous trouvez que cette situation d'analyse est vraiment le goulot d'étranglement de votre application, ALORS il est temps d'essayer de trouver le moyen le plus rapide de résoudre le problème. Je pense que Jeff (et bien d'autres) ont beaucoup écrit sur ce genre de choses.

Vous obtiendrez des résultats différents pour les différentes méthodes selon que vous compilez avec ou non les optimisations. Vous avez essentiellement quelques options :

object o;

//checking with is
o is int

//check type
o.GetType() != typeof( int )

//cast and catch exception
try{ int j = (int) o; } 
catch {}

//use the tryparse
int.TryParse( Convert.ToString( o ), out j )

Vous pouvez facilement configurer une application de console qui essaie chacune de ces 10 000 fois et renvoie des durées pour chacune (tester quand o est un int et quand c'est autre chose).

La méthode try-catch est la plus rapide si l'objet contient un int, et de loin la plus lente si ce n'est pas le cas (encore plus lente que GetType). int.TryParse est assez rapide si vous avez une chaîne, mais si vous avez un objet inconnu, c'est plus lent.

Il est intéressant de noter qu'avec .Net 3.5 et les optimisations activées, la vérification o is int prend le même temps que try-catch lorsque o est en fait un int. o is int n'est que légèrement plus lent si o est en fait autre chose.

FxCop affichera des avertissements si vous faites quelque chose comme :

if( o is int )
    int j = (int) o;

Mais je pense que c'est un bogue dans FxCop - il ne sait pas que int est un type valeur et vous recommande d'utiliser o as int à la place.

Si votre saisie est toujours une chaîne, int.TryParse est préférable, sinon l'opérateur is est le plus rapide.

Comme vous avez une chaîne, je regarderais si vous devez savoir qu'il s'agit d'un entier plutôt que d'un double. Si int.TryParse réussit, alors double.TryParse le sera aussi, vous pouvez donc réduire de moitié le nombre de vérifications - renvoyer soit double soit une chaîne et plancher les doubles lorsque vous attendez un int.

Le problème que vous rencontrez est qu'il pourrait y avoir des situations où la réponse pourrait être les trois types.

3 peut être un entier, un double ou une chaîne !

Cela dépend de ce que vous essayez de faire et de l'importance qu'ils ont d'être d'un type particulier. Il serait peut-être préférable de les laisser tels quels aussi longtemps que vous le pouvez ou, alternativement, d'utiliser une méthode pour marquer chacun d'entre eux (si vous avez le contrôle de la source de la chaîne d'origine).