将对象转换为双精度的最快方法？

Question

将对象转换为双精度对象的最快方法是什么？我现在在一段代码中，上面写着：

var d = double.TryParse(o.ToString(), out d);  // o is the Object...

最初的想法是将其重写为

var d = Convert.ToDouble(o);

但这实际上会更快吗？

编辑：除了运行配置文件（顺便说一下，我向任何开发人员强烈推荐 JetBrains dotTrace），我还运行了 Reflector，这帮助我来了加上以下（或多或少是代码的相关部分）：

if (o is IConvertible)
{
    d = ((IConvertible)o).ToDouble(null);
}
else
{
    d = 0d;
}

原代码double.TryParse()在140ms内执行。新代码在 34 毫秒内执行。我几乎可以肯定这是我应该采取的优化路径，但在我这样做之前，有没有人看到我的“优化”代码有任何问题？提前感谢您的反馈！

Answer 1

使用 System.Diagnostics.Stopwatch 创建一个小型测试应用，看看哪个更快。尽管我认为这不会产生有价值的差异。我会选择Convert.ToDouble 纯粹是为了可读性。

Answer 2

首先，如果您真的想知道哪个更快，您应该编写一个快速测试（使用您希望处理的数据）并为每个选项计时。在不知道o 是（或可能是）什么的情况下很难判断。我怀疑你不会看到太大的不同。

其次，除非您在代码的非常时间关键部分调用这段代码，并且调用它数千次来启动，否则我怀疑它真的很重要。编写好的、干净的代码，然后优化。

Answer 3

我尝试了以下方法。

• double.TryParse
• double.Parse
• Convert.ToDouble

我使用了以下代码。

public static void Main()
{
    string text = "3.14";
    var timer = new Stopwatch();
    timer.Start();
    for (int i = 0; i < 10000000; i++)
    {
        double d;
        d = Convert.ToDouble(text);
        //double.TryParse(text, out d);
        //d = double.Parse(text);
    }
    timer.Stop();
    Console.WriteLine("Time=" + timer.Elapsed.ToString());
    Console.ReadLine();
}

在我的机器上我看到了这些结果。我平均了 3 次不同的跑步。

• double.TryParse = 4.45 秒
• double.Parse = 4.45 秒
• Convert.ToDouble = 4.75 秒

当然，我使用了一个可转换的字符串。如果字符串不可转换，那么我高度怀疑double.TryParse 将是最快的。

Answer 4

你必须做很多这样的事情才能有意义地花时间在这上面。不过，我不是来评判的：

所以，你的代码是这样的：

if (o is IConvertible)
{
    d = ((IConvertible)o).ToDouble(null);
}
else
{
    d = 0d;
}

我想知道你是否会更好

IConvertible convert = o as IConvertible;

if (convert != null)
{
  d = convert.ToDouble(null);
}
else
{
  d = 0d;
}

为您节省双重演员。

Answer 5

您可以尝试做几种不同的事情，这取决于 o 是什么类型的事情。可能是

a) 一个装箱的双精度，而您只想拆箱：

object o = 53.2;
double d = (double)o;

b) 一些其他类型、值或引用，它们可以转换为您想要使用的双精度（实现 IConvertible.ToDouble()）

object o = 53.2M; // a System.Decimal
double d = Convert.ToDouble(o);

或

c) 具有可以被解析为双精度的默认字符串表示形式的东西

object o = "53.2";
double d;
bool convertedOK = double.TryParse(o.ToString(), out d);

从某种意义上说，选项 c 是最长的路程；您正在获取您的对象，询问其字符串表示形式，然后尝试解析该字符串以获得双精度。如果您不需要这样做，这很笨拙，在您的 40,000 次调用示例中，它将创建和丢弃 40,000 个字符串...

如果您知道您的对象将始终包含实现双精度转换的内容，您可以跳过所有这些并选择选项 b。如果您知道您的对象只是一个装箱的双精度对象，请选择最简单的选项 (a) 将其拆箱。

如果你真的不知道 o 会是什么，也许这些方面的东西对你有用？

double d = (o is double) ? (double)o
    : (o is IConvertible) ? (o as IConvertible).ToDouble(null)
    : double.Parse(o.ToString());

（注意：如果 o 包含实现 IConvertible 但不能转换为双精度的内容，或者如果它的字符串表示不能被解析为双精度，这将不起作用）

我没有提到相对速度，但如果拆箱并不比转换为字符串然后解析快得多（除非优化器非常聪明），我会感到惊讶。

使用 .NET 秒表在 LINQPad 中进行的快速测试表明存在很大差异。

IEnumerable<object> myData = new List<object>() { "53.2", 53.2M, 53.2D };
const int iterations = 10000000;
var sw = new Stopwatch();
var results = new List<string>();

foreach (var o in myData)
{
    sw.Reset();
    sw.Start();

    for (var i=0; i < iterations; i++)
    {
        double d = (o is double) ? (double)o
            : (o is IConvertible) ? (o as IConvertible).ToDouble(null)
            : double.Parse(o.ToString());
    }

    sw.Stop();

    results.Add($"{o.GetType()}: {iterations} iterations took {sw.ElapsedMilliseconds}ms");
}

results.Dump();

在我的电脑上给出以下结果

System.String: 10000000 iterations took 1329ms 
System.Decimal: 10000000 iterations took 402ms 
System.Double: 10000000 iterations took 38ms