什么是更快,打开字符串或elseif类型？

这类似于Ted Elliot所建议的,但运行时类型句柄而不是完整类型对象的使用避免了通过反射加载类型对象的开销.

以下是我机器上的一些快速计时:

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 5 types
Method                Time    % of optimal
If/Else               179.67  100.00
TypeHandleDictionary  321.33  178.85
TypeDictionary        377.67  210.20
Switch                492.67  274.21

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 10 types
Method                Time    % of optimal
If/Else               271.33  100.00
TypeHandleDictionary  312.00  114.99
TypeDictionary        374.33  137.96
Switch                490.33  180.71

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 15 types
Method                Time    % of optimal
TypeHandleDictionary  312.00  100.00
If/Else               369.00  118.27
TypeDictionary        371.67  119.12
Switch                491.67  157.59

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 20 types
Method                Time    % of optimal
TypeHandleDictionary  335.33  100.00
TypeDictionary        373.00  111.23
If/Else               462.67  137.97
Switch                490.33  146.22

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 25 types
Method                Time    % of optimal
TypeHandleDictionary  319.33  100.00
TypeDictionary        371.00  116.18
Switch                483.00  151.25
If/Else               562.00  175.99

Testing 3 iterations with 5,000,000 data elements (mode=Random) and 50 types
Method                Time      % of optimal
TypeHandleDictionary  319.67    100.00
TypeDictionary        376.67    117.83
Switch                453.33    141.81
If/Else               1,032.67  323.04

至少在我的机器上,当用作方法输入的类型的分布是随机的时,类型句柄字典方法胜过15种不同类型的所有其他类型.

另一方面,如果输入完全由在if/else链中首先检查的类型组成,那么方法要快得多:

Testing 3 iterations with 5,000,000 data elements (mode=UniformFirst) and 50 types
Method                Time    % of optimal
If/Else               39.00   100.00
TypeHandleDictionary  317.33  813.68
TypeDictionary        396.00  1,015.38
Switch                403.00  1,033.33

相反,如果输入始终是if/else链中的最后一个,那么它具有相反的效果:

Testing 3 iterations with 5,000,000 data elements (mode=UniformLast) and 50 types
Method                Time      % of optimal
TypeHandleDictionary  317.67    100.00
Switch                354.33    111.54
TypeDictionary        377.67    118.89
If/Else               1,907.67  600.52

如果您可以对输入做出一些假设,那么您可以从混合方法中获得最佳性能,其中您执行if/else检查最常见的几种类型,然后如果这些方法失败则回退到字典驱动方法.

我刚刚实现了一个快速测试应用程序并使用ANTS 4进行了分析.
规范:32位Windows XP中的.Net 3.5 sp1,代码以发布模式构建.

300万次测试:

开关:1.842秒

如果:0.344秒.

此外,switch语句结果显示(不出所料)较长的名称需要更长时间.

100万次测试

鲍勃:0.612秒.

吉尔:0.835秒.

马可:1.093秒.

我看起来像"If Else"更快,至少我创建的场景.

class Program
{
    static void Main( string[] args )
    {
        Bob bob = new Bob();
        Jill jill = new Jill();
        Marko marko = new Marko();

        for( int i = 0; i < 1000000; i++ )
        {
            Test( bob );
            Test( jill );
            Test( marko );
        }
    }

    public static void Test( ChildNode childNode )
    {   
        TestSwitch( childNode );
        TestIfElse( childNode );
    }

    private static void TestIfElse( ChildNode childNode )
    {
        if( childNode is Bob ){}
        else if( childNode is Jill ){}
        else if( childNode is Marko ){}
    }

    private static void TestSwitch( ChildNode childNode )
    {
        switch( childNode.Name )
        {
            case "Bob":
                break;
            case "Jill":
                break;
            case "Marko":
                break;
        }
    }
}

class ChildNode { public string Name { get; set; } }

class Bob : ChildNode { public Bob(){ this.Name = "Bob"; }}

class Jill : ChildNode{public Jill(){this.Name = "Jill";}}

class Marko : ChildNode{public Marko(){this.Name = "Marko";}}

首先,你要比较苹果和橘子.您首先需要比较开关类型与开启字符串,然后如果在类型vs比较字符串,然后比较获胜者.

其次,这是OO的设计目标.在支持OO的语言中,切换类型(任何类型)都是指代设计不良的代码气味.解决方案是使用抽象或虚拟方法(或类似的构造,取决于您的语言)从公共基础派生

例如.

class Node
{
    public virtual void Action()
    {
        // Perform default action
    }
}

class Bob : Node
{
    public override void Action()
    {
        // Perform action for Bill
    }
}

class Jill : Node
{
    public override void Action()
    {
        // Perform action for Jill
    }
}

然后,您只需调用childNode.Action(),而不是执行switch语句.

执行开关语句比if-else-if梯形图更快.这是由于编译器能够优化switch语句.对于if-else-if梯形图,代码必须按程序员确定的顺序处理每个if语句.但是,因为switch语句中的每个case都不依赖于早期的情况,所以编译器能够以提供最快执行的方式重新排序测试.

如果你已经完成了课程,我建议使用策略设计模式而不是switch或elseif.