Chaîne de caractères.Format vs ToString()

Quelqu'un peut-il expliquer si il n'y a aucun avantage à faire soit l'une des méthodes suivantes:

decimal d = 12.0m;

//1. how I'd have done it
myLabel.Text = d.ToString();

//2. how I saw someone do it today
myLabel.Text = String.Format("{0}", d);

Juste pour préciser, je ne suis pas d'interrogation de ce que les méthodes de le faire, je suis évidemment heureux avec cela, seulement si il y a peut-être un avantage de performance de l'un sur l'autre dans cet exemple précis.
Je suis conscient de la flexibilité de cultures et de mise en forme proposés par la chaîne.format(), mais j'avais toujours juste " tostring()' des nombres de fixer leur valeur à une étiquette, ou à base de texte de la propriété en général.

Pour moi, la chaîne.format() option semble plus à taper sans avantage supplémentaire ici, mais je me demandais si il y a d'autres "sous le capot" les avantages de faire les choses d'une manière vs les autres.

Si vous n'êtes pas sûr, c'est nul, utilisez le Format de la place.

OriginalL'auteur dougajmcdonald | 2012-05-01

c#string.format tostring

27

J'ai fait une petite référence dans Linqpad:
```
void Main()
{
    int iterations = 1000000;
    decimal d = 12.0m;
    var text = "";

    var sw = Stopwatch.StartNew();
    for (int i = 0; i < iterations; i++)
    {
        //1. how I'd have done it
        text = d.ToString();
    }
    sw.Stop();
    sw.ElapsedMilliseconds.Dump("ToString()");

    sw = Stopwatch.StartNew();
    for (int i = 0; i < iterations; i++)
    {
        //2. how I saw someone do it today
        text = String.Format("{0}", d);
    }
    sw.Stop();
    sw.ElapsedMilliseconds.Dump("Format");
}
```
ToString()
157

Format
264

ToString() recherche constamment plus rapide.

EDIT: je précise que sur mon PC de 10 millions de "Format" des opérations a pris seulement 2,2 secondes. Cela ressemble à un micro-optimisation, et moins que ce que vous faites est extrêmement critiques des performances, ou itératif - il faudrait vous en inquiétez pas trop.

+1 pour les résultats réels.
Cela aurait été à mes attentes, et il ne semble confirmer ce que les autres ont dit à propos du fonctionnement interne de la Chaîne.Format() (c'est à dire à l'aide d'un Générateur), merci pour les résultats.
J'ai ajouté Convert.ToString(d); dans le mélange et mes numéros ont été: ToString() -> 220 Format -> 454 Convertir.ToString() -> 224
J'ai fait les tests de performance réels et confirmé de manière indépendante dans un ASP.Net C# une application web. À l'aide de ToString et l'opérateur '+' est environ 2x plus rapide que l'utilisation de la Chaîne.Format. Chaîne de caractères.Le Format doit faire beaucoup plus sophistiquée analyse de la chaîne de format. Ces petites améliorations qui s'additionnent et peuvent faire une différence dans une page web où chaque milliseconde de temps de chargement de compte. En termes de priorités cependant, cette optimisation n'est généralement pas sur un chemin critique.

OriginalL'auteur Dave Bish
3

format de chaîne de caractères - utilise sous le capot- StringBuilder - ce qui est beaucoup plus rapide pour travailler avec des chaînes.

ToString est la représentation par défaut d'un objet.

Ouais j'apprécie les concepts, mais avec l'exemple ici, les résultats sont équivalents, donc j'étais curieux de savoir si il y a autre chose à prendre en compte. Si La Chaîne.Format() utilise un stringbuilder, cela donnerait à penser que c'est a appeler ToString() sur lui-même de toute façon, et dans cet exemple, vraisemblablement, ce serait plus lent que le défaut ToString() de la représentation de la virgule

OriginalL'auteur Royi Namir
3

string.Format peut être utilisé pour créer d'autres complexes de chaînes, car il peut prendre un params argument ensemble; donc ce n'est pas vraiment une question de pommes VS pommes.

OriginalL'auteur Tejs
2

ToString() est mieux, puisque Format() besoins à l'appel de ToString() sous le capot de toute façon. Si vous avez besoin de spécifier la mise en forme personnalisée, Format() propose des spécificateurs de format alignement/rembourrage. Sinon, il n'y a pas de raison de ne pas utiliser ToString().

ToString() correspond beaucoup mieux à l'auto-documentation du code que Format(), et tout simplement plus de sens.

C'est la façon dont j'ai été voir les choses, je suppose que c'est ce que @Royi dit ci-dessus est le cas, comme vous le dites, je dois appeler ToString() sur un stringbuilder par l'aide .Format(), qui suggère qu'il est en train de créer un StringBuilder pour aucune raison (dans cet exemple).

OriginalL'auteur Kendall Frey
1

Je m'attends à être un marginal avantage de performance de l'appel ToString() car elle n'a pas pour analyser votre chaîne de format. Que, et il lit beaucoup plus bien si vous n'utilisez pas toutes les caractéristiques de caractéristiques de Format().

OriginalL'auteur Tim Rogers

Vous devez vous connecter pour publier un commentaire.