Casting vs Conversion d'un objet toString, quand l'objet est vraiment une chaîne

Question

Ce n'est pas vraiment un problème, mais je suis curieux. Lorsque j'enregistre une chaine de caractères dans disons un DataRow, il est jeté à l'Objet. Lorsque je veux l'utiliser, je dois le jeter ToString. Pour autant que je sais qu'il ya plusieurs façons de le faire, c'est d'abord

string name = (string)DataRowObject["name"]; //valid since I know it's a string

et un autre:

string name = DataRowObject["name"].ToString();

Je m'intéresse à ce qui est la différence entre les deux? Est le premier plus efficace? (C'est juste une spéculation, dans ma tête à la méthode ToString() est mise en œuvre par un mécanisme de bouclage où casting qu'elle "pourrait" être plus rapide, mais ce n'est qu'un "feeling" que j'ai).

Est-il encore un plus rapide / plus élégante façon de faire cela?

Quelqu'un peut-il éclaircir ce point pour moi?

Answer 1

Les deux sont destinés à différents fins. La méthode ToString de tout l'objet est censé renvoyer une chaîne de caractères la représentation de cet objet. Casting est tout à fait différent, et le 'la' clé word effectue un conditionnel exprimées, a été dit. Le "comme" mot-clé en gros dit "donnez-moi une référence de ce type de l'objet si c' l'objet est de ce type", tandis que ToString dit "donnez-moi une représentation de chaîne de cet objet". Le résultat peut être la de même, dans certains cas, mais les deux devraient ne jamais être considérés comme interchangeables parce que, comme je l'ai dit, ils n'existent que dans des fins différentes. Si votre intention est à jeter, alors vous devez toujours utiliser un casting, PAS ToString.

à partir de http://www.codeguru.com/forum/showthread.php?t=443873

voir aussi http://bytes.com/groups/net-c/225365-tostring-string-cast

Answer 2

Si vous savez que c'est un String puis par tous les moyens la convertir en une String. Le moulage de votre objet va être plus rapide que d'appeler une méthode virtuelle.

Edit: Voici les résultats de certains de benchmarking:

============ Casting vs. virtual method ============
cast 29.884 1.00
tos  33.734 1.13

J'ai utilisé Jon Skeet l' BenchmarkHelper comme ceci:

using System;
using BenchmarkHelper;

class Program
{
    static void Main()
    {
    	Object input = "Foo";
    	String output = "Foo";

    	var results 
           = TestSuite.Create("Casting vs. virtual method", input, output)
    	    .Add(cast)
    	    .Add(tos)
    	    .RunTests()
    	    .ScaleByBest(ScalingMode.VaryDuration);

    	results.Display(ResultColumns.NameAndDuration | ResultColumns.Score,
    			results.FindBest());
    }

    static String cast(Object o)
    {
    	return (String)o;
    }

    static String tos(Object o)
    {
    	return o.ToString();
    }
}

Il semble donc que le casting est en fait légèrement plus rapide que d'appeler ToString().

Answer 3

Dans votre cas, il est préférable de laisser le transtype, car .ToString () peut masquer des bogues. Par exemple, votre schéma de base de données a changé et le nom n’est plus de type chaîne, mais avec .ToString (), votre code fonctionne toujours. Donc, dans ce cas, il est préférable d’utiliser le transtypage.

Voici l'implémentation de String.ToString () - rien de spécial =)

 public override string ToString()
{
    return this;
}
 

Answer 4

Le downcasting est une opération relativement lente car le CLR doit effectuer diverses vérifications de type à l'exécution. Toutefois, dans ce scénario particulier coulée à string est plus approprié que d' appeler ToString() par souci de cohérence (vous ne pouvez pas appeler ToInt32 en object , mais converti en int ) et maintenabilité.

Answer 5

Dans ce cas:

 string name = DataRowObject["name"].ToString();
 

comme il s'agit d'un string , je pense que la méthode ToString() d'un objet chaîne est simple comme suit:

 return this;
 

donc à mon humble avis, il n’ya aucune pénalité de performance.

PS Je suis un programmeur Java, alors cette réponse n’est qu’une hypothèse.