使用C#哪个更快-System.Convert.ToString（objthatistring）或（string）objthatistring？

或者是aswers中指出的objthatistring.ToString（）。。 更快而不是更聪明。

演员阵容

（字符串）obj

应该更快。Convert类实际上会转换不同类的对象，在这种情况下会更慢。

我认为

（string）objthatistring

更快，因为编译器能够在编译时进行这种转换

---

然而，Jeff Atwood认为这并不重要（）

直接强制转换不需要做任何检查，除了运行时类型检查-我希望强制转换更快

您可能还想考虑<代码> ObjthAtStist.toStrug（）< /C> >；因为（对于

string

）这只是

返回这个

，它应该很快-肯定比

Convert.ToString

快。然后是运行时类型检查和虚拟调用之间的竞争；实际上，两者都非常、非常快。

演员阵容更快

在一些开销之后，

Convert.ToString

最终将执行强制转换。它实际上是以尝试将其强制转换为

IConvertible

，然后在其上调用虚拟方法

ToString

的形式进行的。因此，是虚拟呼叫对

字符串进行了实际的转换
有句谚语说“数字说明了一切”。这意味着你可以测量它，而不是假设它

因此，打包一个测试应用程序，运行测试并验证结果

真正的问题可能是：
我如何衡量哪种方式更快？
@thijs:
下面是一个快速测试：

public class ToStringTest
{
    private object mString = "hello world!";
    Stopwatch sw = new Stopwatch();
    private List<long> ConvertToStringTimes = new List<long>();
    private List<long> ToStringTimes = new List<long>();
    private List<long> CastToStringTimes = new List<long>();

    public ToStringTest()
    {

        for (int i = 0; i < 100000; i++)
        {
            sw.Start();
            ConvertToString();
            sw.Stop();
            ConvertToStringTimes.Add(sw.ElapsedTicks);
            sw.Reset();

            sw.Start();
            ToString();
            sw.Stop();
            ToStringTimes.Add(sw.ElapsedTicks);
            sw.Reset();

            sw.Start();
            CastToString();
            sw.Stop();
            CastToStringTimes.Add(sw.ElapsedTicks);
            sw.Reset();    
        }
        Console.WriteLine("Average elapsed ticks after converting {0} strings",ConvertToStringTimes.Count);
        Console.WriteLine("ConvertToString: {0} ticks", ConvertToStringTimes.Average() );
        Console.WriteLine("ToString: {0} ticks", ToStringTimes.Average());
        Console.WriteLine("CastToString: {0} ticks",  CastToStringTimes.Average());
    }

    private string ConvertToString()
    {
        return Convert.ToString(mString);
    }

    public override string ToString()
    {
        return mString.ToString();
    }

    public string CastToString()
    {
        return (string) mString;
    }
}

公共类到字符串测试
{
私有对象mString=“你好，世界！”；
秒表sw=新秒表（）；
私有列表ConvertToStringTimes=新列表（）；
private List ToStringTimes=新列表（）；
私有列表CastToStringTimes=新列表（）；
公共ToString测试（）
{
对于（int i=0；i<100000；i++）
{
sw.Start（）；
ConvertToString（）；
sw.Stop（）；
ConvertToStringTimes.Add（sw.ElapsedTicks）；
sw.Reset（）；
sw.Start（）；
ToString（）；
sw.Stop（）；
ToStringTimes.Add（sw.ElapsedTicks）；
sw.Reset（）；
sw.Start（）；
CastToString（）；
sw.Stop（）；
CastToStringTimes.Add（sw.ElapsedTicks）；
sw.Reset（）；
}
WriteLine（“转换{0}个字符串后的平均运行时间”，ConvertToStringTimes.Count）；
WriteLine（“ConvertToString:{0}个ticks”，ConvertToString.Average（））；
WriteLine（“ToString:{0}个ticks”，ToString时间.Average（））；
WriteLine（“CastToString:{0}个ticks”，CastToStringTimes.Average（））；
}
私有字符串ConvertToString（）
{
返回Convert.ToString（mString）；
}
公共重写字符串ToString（）
{
返回mString.ToString（）；
}
公共字符串CastToString（）
{
返回（字符串）mString；
}
}

结果：

转换100000个字符串后的平均运行时间

ConvertToString:611.97372滴答声

ToString:586.51461滴答声

CastToString:582.25266滴答声
我认为速度差太小了，根本不值得担心，转换的可能性很大。ToString只是在内部进行强制转换。@Nathan-但是方法调用的额外开销。一般来说，操作会比方法快，但我完全同意这是微观优化。@annakata当然，但是的，这是微观优化的一个肯定案例。编译器只会在已知变量为字符串时介入；否则，它将发出一个运行时类型检查。最后是一个没有任何“shoulds”或“woulds”的答案：）干得好。很好-一个明确的+1；我不知道这个问题什么时候变成了维基——这似乎很不幸；在我看来，你应该得到一些分数。你的期望与下面的测试结果相符！