C#在静态调用之间缓存值

我有一个抽象类，它在几个嵌套循环中运行一系列计算量相当大的静态函数

在少数循环中，我需要获得一个日期列表，这些日期以逗号分隔的字符串存储在.settings文件中。然后我将它们解析为日期时间并使用它们

问题是，我一次又一次地解析这些字符串，这占用了相当多的CPU时间（显然）。分析表明，在这些操作上浪费了20%的核心算法。如果我能以某种方式将它们缓存在静态函数可以访问的地方，那么它将节省我大量的处理时间

最简单的选择是在计算开始时解析DateTime列表，然后将该列表传递给每个子函数。这当然会减少CPU的工作，但这意味着当在核心算法之外调用时，子函数需要接受这个列表。调用父静态函数之一时，为什么需要DateTime列表，这一点从直觉上讲是没有道理的

另一个需要解决的问题是使类不是抽象的，函数是非静态的，并将日期列表等存储在每个要访问的函数的变量中。我想用静态函数抽象它的原因是，我不想每次手动调用一个子函数时都要实例化这个类

理想情况下，我想做的是对列表进行一次解析并将其存储在内存中的某个位置。然后，当我进行后续迭代时，我可以检查它是否为null，然后我可以使用它。如果它为null（可能是因为我在第一次迭代中），那么我知道我需要解析它

我想我可以有一个.settings文件，里面有列表。我永远不会将设置文件保存到磁盘，但它基本上允许在静态调用之间进行存储

我知道这一切都很混乱——我只是尽量避免在可行的情况下重新编写一千行静态代码

如果你们都认为这是一个糟糕的想法，那么我将举起我的白旗，重新写下这一切

另一个需要解决的问题是使类不是抽象的，函数是非静态的，并将日期列表等存储在每个要访问的函数的变量中。我想用静态函数抽象它的原因是，我不想每次手动调用一个子函数时都要实例化这个类

这样做。类的存在是为了封装状态。如果您将缓存存储在静态的地方，那么您只会在需要添加并行性或重构代码时给自己制造麻烦

我不知道你说的第二部分（“手动呼叫”）是什么意思。你是说在测试时

另一个需要解决的问题是使类不是抽象的，函数是非静态的，并将日期列表等存储在每个要访问的函数的变量中。我想用静态函数抽象它的原因是，我不想每次手动调用一个子函数时都要实例化这个类

这样做。类的存在是为了封装状态。如果您将缓存存储在静态的地方，那么您只会在需要添加并行性或重构代码时给自己制造麻烦

---

我不知道你说的第二部分（“手动呼叫”）是什么意思。你的意思是在测试时？

如果日期是只读的，那么就很简单了-在一个类上声明一个静态属性，如果值不存在，它将加载这些值，并将它们存储在一个静态变量中-类似这样：

public class DateList
{
  private static List<DateTime> mydates = null;  // new List<DateTime>();  haha, oops

  public static List<DateTime> Current {
    get {
      if(mydates == null)
      {
        lock(typeof(DateList)) {
          if(mydates == null) {
            mydates = LoadDates();
          }
        }
      }
      return mydates;
    }
  }

  // thanks to Porges - if you're using .NET 4 then this is cleaner and achieves the same result:
  private static Lazy<List<DateTime>> mydates2 = new Lazy<List<DateTime>>(() => LoadDates(), true);
  public static List<DateTime> Current2
  {
     return mydates2.Value;
  }

}

---

注意，如果日期不是只读的，那么你就必须更详细地考虑事情。

< P>如果日期是只读的，那么它是非常简单的——在一个类上声明一个静态属性，如果这些值不存在，则将其存储在静态变量中，例如：

public class DateList
{
  private static List<DateTime> mydates = null;  // new List<DateTime>();  haha, oops

  public static List<DateTime> Current {
    get {
      if(mydates == null)
      {
        lock(typeof(DateList)) {
          if(mydates == null) {
            mydates = LoadDates();
          }
        }
      }
      return mydates;
    }
  }

  // thanks to Porges - if you're using .NET 4 then this is cleaner and achieves the same result:
  private static Lazy<List<DateTime>> mydates2 = new Lazy<List<DateTime>>(() => LoadDates(), true);
  public static List<DateTime> Current2
  {
     return mydates2.Value;
  }

}

---

<>注意，如果日期不是只读的，那么你必须更详细地考虑事情。

不，它是一个巨大的调度算法，它由许多模块组成。当我想要生成一个初始计划时，完整的算法从头到尾运行。然而，之后，用户可以手动调整时间表，在这段时间内，只调用某些模块，而不是顶级算法。大多数模块不需要这个日期时间列表。我要补充的是，这个日期列表并没有真正改变。它是一个公共假日列表，每年左右只能在“设置”窗口中更新一次。所以我不认为缓存解析后的字符串会导致并行性等方面的问题？@Ozzah：我想你的意思是它是作为每次处理运行的一部分读取的。尽管如此，如果你有state，那么拥有一个实例会更干净——作为类的消费者，你不希望

静态方法在调用之间改变它们的行为。不，这是一个由许多模块组成的巨大调度算法。当我想要生成一个初始计划时，完整的算法从头到尾运行。然而，之后，用户可以手动调整时间表，在这段时间内，只调用某些模块，而不是顶级算法。大多数模块不需要这个日期时间列表。我要补充的是，这个日期列表并没有真正改变。它是一个公共假日列表，每年左右只能在“设置”窗口中更新一次。所以我不认为缓存解析后的字符串会导致并行性等方面的问题？@Ozzah：我想你的意思是它是作为每次处理运行的一部分读取的。不过，如果您有state，那么拥有一个实例会更干净-作为类的使用者，您不希望
静态方法在调用之间改变它们的行为。@Nathan谢谢-我知道静态成员，但不知道您可以这样设置它们。我会考虑这一点，但我认为这都是GETT。