局部变量和从方法调用的变量之间的差异？C#

我想知道什么更快。帮帮我

我在如下方法中声明了一个变量：

    public static Regex FindNumber()
{ return new Regex(@"\d+", RegexOptions.IgnoreCase | RegexOptions.Compiled); }

如您所见，它返回一个正则表达式

我还有另一种方法，看起来是这样的：

    private static string TestOne(string RawData)
{
    Regex rgxFindNumber = FindNumber();
    Regex rgxFindDays = FindDays();
    for (int i = 0; i < mc.Count; i++)
    {
        int days = Convert.ToInt32(rgxFindNumber.Match(rgxFindDays.Match(mc[i].Value).Value).Value);
    }
    return RawData;
}

private静态字符串TestOne（字符串RawData）
{
Regex rgxFindNumber=FindNumber（）；
Regex rgxFindDays=FindDays（）；
对于（int i=0；i

现在TestOne方法会更快还是Test2更快

        private static string TestTwo(string RawData)
{
    for (int i = 0; i < mc.Count; i++)
    {
        int days = Convert.ToInt32(FindNumber().Match( FindDays().Match(mc[i].Value).Value).Value);
    }
    return RawData;
}

private静态字符串TestTwo（字符串RawData）
{
对于（int i=0；i

现在我很好奇，因为TestOne可以在我的代码中被称为非常棒的一部分，所以我想知道什么更适合实现

谢谢各位

---

**编辑：**我使用的代码有一个非常大的类。它是一个基于文本的策略游戏的文本解析器。我正在尝试重构它一点，这就是我在这里想知道的。如果我为正则表达式创建了一个私有变量，它不是每次访问类时都会运行吗？这是我要问你的问题。

我相信

TestOne

会更快，因为在

TestTwo

中，每次循环时都会创建一个新的

Regex

对象。如果

FindDays

的实现方式与

FindNumber

相同，则会更糟糕，因为您将创建两个对象。

我相信

TestOne

会更快，因为在

TestTwo

中，您每次循环都会创建一个新的

Regex

对象。如果

FindDays

的实现方式与

FindNumber

相同，则会更糟糕，因为您将创建两个对象。

从技术上讲，TestOne会更快，因为TestTwo通过调用FindNumber（）添加堆栈帧

我不知道会有多大的不同，我怀疑会有多大。您的方法是静态的，所以实际上它只是创建对象，应该非常快

我的问题是，为什么要使用函数调用一遍又一遍地返回相同的字符串？为什么不声明一个实变量呢

像

---

从技术上讲，TestOne会更快，因为Test2通过调用FindNumber（）添加堆栈帧

我不知道会有多大的不同，我怀疑会有多大。您的方法是静态的，所以实际上它只是创建对象，应该非常快

我的问题是，为什么要使用函数调用一遍又一遍地返回相同的字符串？为什么不声明一个实变量呢

像

---

TestOne

将比

TestTwo

更快，因为您没有为每个循环迭代创建新的正则表达式

这有两个好处：

• 用于解析和构造正则表达式对象的时间只执行一次，而不是

  mc.Count

  次
• 由于构造的对象较少，因此对垃圾收集的压力较小

不过，我会更进一步。如果您总是要返回相同的正则表达式，并且您关心速度，我会将regex对象缓存在静态字段中

例如，您可以考虑如下：

private static Regex _FindNumber;
public static Regex FindNumber()
{
    if (_FindNumber == null)
        _FindNumber = new Regex(@"\d+", RegexOptions.IgnoreCase | RegexOptions.Compiled);
    return _FindNumber;
}

这将只创建一个对象total，并将其保留

然而，这是我真正的答案

要真正知道哪一个将是最快的，您必须测量您的代码，可以选择使用我的变体进行良好的测量，然后决定。永远不要在没有硬数据的情况下决定优化，你可能会花时间重写代码，这可能会引入新的bug，需要修复，你会花更多的时间在这些bug上，结果只会获得另外1%的性能

大的优化是通过算法来完成的，比如改变排序算法的类型，然后，如果必要的话，再进行局部优化，比如循环调优

---

话虽如此，我至少会避免在循环中构造对象，这只是常识。

TestOne

将比

TestTwo

更快，因为您不会为每个循环迭代创建新的正则表达式

这有两个好处：

• 用于解析和构造正则表达式对象的时间只执行一次，而不是

  mc.Count

  次
• 由于构造的对象较少，因此对垃圾收集的压力较小

不过，我会更进一步。如果您总是要返回相同的正则表达式，并且您关心速度，我会将regex对象缓存在静态字段中

例如，您可以考虑如下：

private static Regex _FindNumber;
public static Regex FindNumber()
{
    if (_FindNumber == null)
        _FindNumber = new Regex(@"\d+", RegexOptions.IgnoreCase | RegexOptions.Compiled);
    return _FindNumber;
}

这将只创建一个对象total，并将其保留

然而，这是我真正的答案

要真正知道哪一个将是最快的，您必须测量您的代码，可以选择使用我的变体进行良好的测量，然后决定。永远不要在没有硬数据的情况下决定优化，你可能会花时间重写代码，这可能会引入新的bug，需要修复，你会花更多的时间在这些bug上，结果只会获得另外1%的性能

大的优化是通过算法来完成的，比如改变排序算法的类型，然后，如果必要的话，再进行局部优化，比如循环调优

---

话虽如此，我至少会避免在循环中构造对象，这只是常识。

我使用的代码有一个非常大的类。它是一个基于文本的策略游戏的文本解析器。我正在尝试重构它一点，这就是我在这里想知道的。如果我为正则表达式创建一个私有变量，我会