c# - 检查实例是否为空VS调用空函数(C#)

Question

介绍

因此，我在制作游戏时，在考虑如何构造和更新所有游戏对象。我（案例1）是否创建一个简单的GameObj作为父类，并在virtual Update方法中放置一些物理对象，在virtual Draw中放置一些默认图形，等等，并使其他所有对象（墙壁，敌人，玩家... ）作为孩子，或者我（情况2）使用this article中所述的组件。简而言之，作者解释说，我们可以创建用于用户输入，物理更新和绘制的界面（让我们停在这3个位置），并使用这些界面的预编程实例来描述我们的GameObj。

现在，在两种情况下，我都会得到一个GameObj类的循环。
在情况1中，可能看起来像这样

// in Update function of the level class
for(int i = 0; i < gameObjList.Count; i++)
{
    gameObjList[i].Update();
}

在第2种情况下，像这样

// in UpdatePhysics function of the level class
for(int i = 0; i < gameObjList.Count; i++)
{
    gameObjList[i].PhysicComponent.Update();
}

对于其他接口（例如 InputComponent.Update和 DrawComponent.Draw（或 CollisionComponent.Check(gameObj[x])，我不知道）），依此类推（在情况2中）。


列出的原因是要在一个关卡类中，该关卡可以照顾我们所有的游戏对象


考虑 if ( x != null )的原因
在这两种情况下，我们都可能需要调用 if ( x != null )。在情况1中，我们可能不想一直删除并添加到 gameObjList，而是回收实例，因此我们将它们设置为 null，而无需执行 gameObjList.Remove(x)的操作。在第2种情况下，也许我们希望不能设置某些组件，因此我们必须要求 if (gameObjList[i].someComponent != null)能够调用 gameObjList[i].someComponent.Update()。


考虑调用空函数的原因
同样在两种情况下，我们都可以调用一个空函数（例如 public void myFunction(){}）。让我们考虑一下自我解释的 Wall类。它的存在只是为了在那里。 ID不会更新，但与其他 GameObj有一定关系。另外，案例1中的某些子对象，比如说 MovingWall或 Platform将进行某种更新。对于案例2，我们总是可以声明一个默认的空类 someComponent，其 Update函数将为空，因此，如果在构造函数中未设置该类的实例，则该类的实例将设置为我们的 GameObj组件。 。也许像这样

public GameObj(IPhysicsComponent physicsComponent, ...){
    if(physicsComponent == null)
        physicsComponent = PhysicsComponent.Default;

    this.physicsComponent = physicsComponent;
}

研究
现在，我没有找到在我们这里构建的游戏引擎中最有效的方法。以下是我刚刚测试过的一些示例（请注意其中一些仅供参考）：
1.空循环
2.清空功能
3. if(x != null) x.empyFunction(); x始终为空
4. x?.emptyFunction(); x始终为空
5. if(x != null) x.empyFunction(); x不为null
6. x?.emptyFunction(); x不为null
7. myClass.staticEmptyFunction();

这7个点分别测试了10万次，10000次。下面的代码是我测试过的代码。您可以在本地运行，更改某些静态变量，结果将显示在运行程序的文件夹中的“ result.txt”中。这是代码：

public enum TimeType
{
    emptyLoop = 1,
    loopEmptyFunction = 2,
    loopNullCheck = 3,
    loopNullCheckShort = 4,
    loopNullCheckInstanceNotNull = 5,
    loopNullCheckInstanceNotNullShort = 6,
    loopEmptyStaticFunction = 7
}

class myTime
{
    public double miliseconds { get; set; }
    public long ticks { get; set; }
    public TimeType type { get; set; }

    public myTime() { }
    public myTime(Stopwatch stopwatch, TimeType type)
    {
        miliseconds = stopwatch.Elapsed.TotalMilliseconds;
        ticks = stopwatch.ElapsedTicks;
        this.type = type;
    }

}

class myClass
{
    public static void staticEmptyFunction() { }
    public void emptyFunction() { }
}

class Program
{
    static List<myTime> timesList = new List<myTime>();
    static int testTimesCount = 10000;
    static int oneTestDuration = 100000;


    static void RunTest()
    {
        Stopwatch stopwatch = new Stopwatch();

        Console.Write("TEST ");

        for (int j = 0; j < testTimesCount; j++)
        {
            Console.Write("{0}, ", j + 1);
            myClass myInstance = null;


            // 1. EMPTY LOOP
            stopwatch.Start();
            for (int i = 0; i < oneTestDuration; i++)
            {

            }
            stopwatch.Stop();
            timesList.Add(new myTime(stopwatch, (TimeType)1));
            stopwatch.Reset();


            // 3. LOOP WITH NULL CHECKING (INSTANCE IS NULL)
            stopwatch.Start();
            for (int i = 0; i < oneTestDuration; i++)
            {
                if (myInstance != null)
                    myInstance.emptyFunction();
            }
            stopwatch.Stop();
            timesList.Add(new myTime(stopwatch, (TimeType)3));
            stopwatch.Reset();


            // 4. LOOP WITH SHORT NULL CHECKING (INSTANCE IS NULL)
            stopwatch.Start();
            for (int i = 0; i < oneTestDuration; i++)
            {
                myInstance?.emptyFunction();
            }
            stopwatch.Stop();
            timesList.Add(new myTime(stopwatch, (TimeType)4));
            stopwatch.Reset();


            myInstance = new myClass();

            // 2. LOOP WITH EMPTY FUNCTION
            stopwatch.Start();
            for (int i = 0; i < oneTestDuration; i++)
            {
                myInstance.emptyFunction();
            }
            stopwatch.Stop();
            timesList.Add(new myTime(stopwatch, (TimeType)2));
            stopwatch.Reset();


            // 5. LOOP WITH NULL CHECKING (INSTANCE IS NOT NULL)
            stopwatch.Start();
            for (int i = 0; i < oneTestDuration; i++)
            {
                if (myInstance != null)
                    myInstance.emptyFunction();
            }
            stopwatch.Stop();
            timesList.Add(new myTime(stopwatch, (TimeType)5));
            stopwatch.Reset();


            // 6. LOOP WITH SHORT NULL CHECKING (INSTANCE IS NOT NULL)
            stopwatch.Start();
            for (int i = 0; i < oneTestDuration; i++)
            {
                myInstance?.emptyFunction();
            }
            stopwatch.Stop();
            timesList.Add(new myTime(stopwatch, (TimeType)6));
            stopwatch.Reset();


            // 7. LOOP WITH STATIC FUNCTION
            stopwatch.Start();
            for (int i = 0; i < oneTestDuration; i++)
            {
                myClass.staticEmptyFunction();
            }
            stopwatch.Stop();
            timesList.Add(new myTime(stopwatch, (TimeType)7));
            stopwatch.Reset();
        }

        Console.WriteLine("\nDONE TESTING");
    }

    static void GetResults()
    {
        // SUMS
        double sum1t, sum2t, sum3t, sum4t, sum5t, sum6t, sum7t,
            sum1m, sum2m, sum3m, sum4m, sum5m, sum6m, sum7m;
        sum1t = sum2t = sum3t = sum4t = sum5t = sum6t = sum7t =
            sum1m = sum2m = sum3m = sum4m = sum5m = sum6m = sum7m = 0;

        foreach (myTime time in timesList)
        {
            switch (time.type)
            {
                case (TimeType)1: sum1t += time.ticks; sum1m += time.miliseconds; break;
                case (TimeType)2: sum2t += time.ticks; sum2m += time.miliseconds; break;
                case (TimeType)3: sum3t += time.ticks; sum3m += time.miliseconds; break;
                case (TimeType)4: sum4t += time.ticks; sum4m += time.miliseconds; break;
                case (TimeType)5: sum5t += time.ticks; sum5m += time.miliseconds; break;
                case (TimeType)6: sum6t += time.ticks; sum6m += time.miliseconds; break;
                case (TimeType)7: sum7t += time.ticks; sum7m += time.miliseconds; break;
            }
        }

        // AVERAGES
        double avg1t, avg2t, avg3t, avg4t, avg5t, avg6t, avg7t,
            avg1m, avg2m, avg3m, avg4m, avg5m, avg6m, avg7m;

        avg1t = sum1t / (double)testTimesCount;
        avg2t = sum2t / (double)testTimesCount;
        avg3t = sum3t / (double)testTimesCount;
        avg4t = sum4t / (double)testTimesCount;
        avg5t = sum5t / (double)testTimesCount;
        avg6t = sum6t / (double)testTimesCount;
        avg7t = sum7t / (double)testTimesCount;

        avg1m = sum1m / (double)testTimesCount;
        avg2m = sum2m / (double)testTimesCount;
        avg3m = sum3m / (double)testTimesCount;
        avg4m = sum4m / (double)testTimesCount;
        avg5m = sum5m / (double)testTimesCount;
        avg6m = sum6m / (double)testTimesCount;
        avg7m = sum7m / (double)testTimesCount;

        string fileName = "/result.txt";
        using (StreamWriter tr = new StreamWriter(AppDomain.CurrentDomain.BaseDirectory + fileName))
        {
            tr.WriteLine(((TimeType)1).ToString() + "\t" + avg1t + "\t" + avg1m);
            tr.WriteLine(((TimeType)2).ToString() + "\t" + avg2t + "\t" + avg2m);
            tr.WriteLine(((TimeType)3).ToString() + "\t" + avg3t + "\t" + avg3m);
            tr.WriteLine(((TimeType)4).ToString() + "\t" + avg4t + "\t" + avg4m);
            tr.WriteLine(((TimeType)5).ToString() + "\t" + avg5t + "\t" + avg5m);
            tr.WriteLine(((TimeType)6).ToString() + "\t" + avg6t + "\t" + avg6m);
            tr.WriteLine(((TimeType)7).ToString() + "\t" + avg7t + "\t" + avg7m);
        }
    }

    static void Main(string[] args)
    {
        RunTest();

        GetResults();

        Console.ReadLine();
    }
}

当我将所有数据放入excel并制作图表时，它看起来像这样（DEBUG）：



编辑-发行版本。我想这回答了我的问题。




问题是
Q1。使用哪种方法更有效？
Q2。在什么情况下？
Q3。是否有官方文件？
Q4。还有其他人对此进行过测试吗？
Q5。有没有更好的方法来测试（我的代码有错误）？
Q6。是否存在更好的方法来解决需要快速而有效地更新的大量实例的问题，例如在每一帧中？
编辑Q7。为什么在发行版中执行静态方法需要花费更长的时间？

Answer 1

正如@ grek40所建议的那样，我进行了另一项测试，在开始测试之前我叫了100次myClass.staticEmptyFunction();以便可以兑现。我也确实将testTimesCount设置为10000，并且将oneTestDuration设置为1000000。结果如下：

现在，它似乎更加稳定。甚至您可以发现的微小差异也归咎于我在后台运行的Google Chrome，Excel和洪水。我之所以问这些问题，是因为我认为会有更大的差异，但是我猜想优化工作比我预期的要好得多。我还猜测没有人进行此测试，因为他们可能知道它背后有C，并且人们在优化方面做了大量工作。