C# 传递引用和使用局部变量之间的性能差异

希望我的问题还没有被回答，我只发现了，但它并没有真正回答我的确切问题

基本上我有一个类MyClass，它包含另一个类设置的本地成员currentSettings。MyClass包含一个DoStuff方法，该方法使用设置对象的任何对象中包含的信息

现在的情况是：永远不会从类本身调用该方法。其他一些类将包含一个MyClass对象，并且仅从该对象调用该方法。现在我有两种可能性：

class MyClass
{
    Settings currentSettings = new Settings();

    public void DoStuff()
    {
        //do stuff here using things stored in "currentSettings"
    }

    public void DoStuff(Settings settings)
    {
        //do stuff here using things stored in "settings"
    }
}

class SomeClass
{
    MyClass myClass = new MyClass();

    ...
    //call method somewhere, with two different options:
    myClass.DoStuff();

    myClass.DoStuff(myClass.currentSettings);
}

当然，第二个变体似乎有点过于复杂，但是，它让我可以自由地向它传递任何设置，这些设置可能不是本地成员currentSettings，并且在某些情况下我需要这些设置

我现在关心的是这两种选择之间的性能差异，以及引用传递是否比使用本地设置慢很多，因为这种方法可能经常被每秒调用几百次

---

编辑：我在答案中发布了一个小的性能测试，没有发现这两种方法之间有任何显著差异。

应该没有什么性能差异。您所做的只是重新排列一些指令，所有这些指令都处理本地内存

当然，第二种变体似乎有点过于复杂

将一个参数传递给一个方法一点也不过分复杂

它让我可以自由地向它传递任何设置，这些设置可能不是本地成员currentSettings，并且在某些情况下我需要这些设置

---

仅该语句的第二部分就告诉我应该使用该参数。

性能差异应该很小甚至没有。您所做的只是重新排列一些指令，所有这些指令都处理本地内存

当然，第二种变体似乎有点过于复杂

将一个参数传递给一个方法一点也不过分复杂

它让我可以自由地向它传递任何设置，这些设置可能不是本地成员currentSettings，并且在某些情况下我需要这些设置

---

仅该语句的第二部分就告诉我应该使用该参数。

最好的答案是告诉您对其进行基准测试，并亲自查看结果

首先，我想说你不会注意到两者之间的显著差异。您正在传递一个引用，它在幕后只是一个C指针。我猜大部分cpu时间都在方法本身内部，而不是调用它

---

我将等待您的反馈，甚至是更好的基准测试结果。

最好的答案是告诉您进行基准测试并亲自查看结果

首先，我想说你不会注意到两者之间的显著差异。您正在传递一个引用，它在幕后只是一个C指针。我猜大部分cpu时间都在方法本身内部，而不是调用它

---

我将等待您的反馈，甚至是更好的基准测试结果。

好的，我已经做了一个快速的脏性能测试，结果发现差异完全不明显：

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        MyClass mc = new MyClass();
        Stopwatch sw = new Stopwatch();
        Settings set = new Settings();
        sw.Start();
        for (int i = 0; i < 1000000; i++)
        {
            mc.DoStuff();
        }
        sw.Stop();
        tb1.Text = sw.ElapsedTicks.ToString();

        sw.Restart();
        for (int i = 0; i < 1000000; i++)
        {
            mc.DoStuff(set);
        }
        sw.Stop();
        tb2.Text = sw.ElapsedTicks.ToString();

    }
}

class MyClass
{
    Settings currentSettings = new Settings();

    public void DoStuff()
    {
        int test = 0;
        for(int k = 0; k < 10 ; k++)
        {
            test += currentSettings.i + currentSettings.j;
        }

    }

    public void DoStuff(Settings settings)
    {
        int test = 0;
        for (int k = 0; k < 10; k++)
        {
            test += settings.i + settings.j;
        }
    }
}

class Settings
{
    public int i = 1, j = 2;
}

---

虽然我已经注意到将循环中的重复次数设置为10000次，但引用传递几乎总是更快，但是这可能是由于许多原因，因为它只需要几千次的滴答声。

好的，我已经做了一个快速脏性能测试，结果发现差异完全不明显：

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        MyClass mc = new MyClass();
        Stopwatch sw = new Stopwatch();
        Settings set = new Settings();
        sw.Start();
        for (int i = 0; i < 1000000; i++)
        {
            mc.DoStuff();
        }
        sw.Stop();
        tb1.Text = sw.ElapsedTicks.ToString();

        sw.Restart();
        for (int i = 0; i < 1000000; i++)
        {
            mc.DoStuff(set);
        }
        sw.Stop();
        tb2.Text = sw.ElapsedTicks.ToString();

    }
}

class MyClass
{
    Settings currentSettings = new Settings();

    public void DoStuff()
    {
        int test = 0;
        for(int k = 0; k < 10 ; k++)
        {
            test += currentSettings.i + currentSettings.j;
        }

    }

    public void DoStuff(Settings settings)
    {
        int test = 0;
        for (int k = 0; k < 10; k++)
        {
            test += settings.i + settings.j;
        }
    }
}

class Settings
{
    public int i = 1, j = 2;
}

---

虽然我注意到将循环中的重复次数设置为10000次，但引用传递几乎总是更快，但这可能是由于许多原因，因为它只需要几千次。

尝试一下，自己测量一下，但性能差异应该接近于零。抱歉，是的，我当然可以而且会自己做。这是一个相当普遍的问题，在一些随机的例子中是否会有显著的差异，我不知道。不要为了微不足道的性能提高而牺牲一个好的软件设计，假设，而且我相信，在这种情况下，没有显着的增益，请自己尝试并测量它，但是应该会有接近零的性能差异。对不起，是的，我当然可以而且会自己做。这是一个相当普遍的问题，在一些随机的情况下是否会有显著的差异，我不知道。不要为了微不足道的性能提高而牺牲一个好的软件设计，我相信，在这种情况下，没有显著的收益需要您的回答。我问这个问题的主要原因是，我可以选择简单地实现方法的两个重载，并根据将使用的设置的选择来调用它。但是对于这一点，我不得不重新编程，我想知道这在性能方面是否值得

---

在编译时计算，所以在运行时有很多重载没有区别。谢谢你的回答。我问这个问题的主要原因是，我可以选择简单地实现方法的两个重载，并根据将使用的设置的选择来调用它。但是，对于这一点，我不得不重新编程，我想知道在性能方面是否值得。如果您想知道，正确的重载方法是在编译时计算的，所以在运行时有许多重载没有区别。我已经根据您的要求发布了我的问题的答案。谢谢你的回复。我已经根据你的要求发布了我的问题的答案。谢谢你的回复。