如何拥有C#只读功能但不限于构造函数？

Question

C#“readonly”关键字是一个修饰符，当字段声明包含它时，对声明引入的字段的赋值只能作为声明的一部分或同一类的构造函数中发生。

现在假设我确实想要这个“赋值一次”约束，但我宁愿允许在构造函数之外完成赋值，可能是惰性/延迟评估/初始化。

我怎么能这么做呢？是否可以以一种很好的方式做到这一点，例如是否可以编写一些属性来描述这一点？

Answer 1

如果我正确理解你的问题，听起来你只想设置一个字段的值一次（第一次），并且不允许此后设置它。如果是这样，那么之前所有关于使用 Lazy（和相关）的帖子可能会有用。但如果您不想使用这些建议，也许您可​​以这样做：

public class SetOnce<T> 
{
    private T mySetOnceField;
    private bool isSet;

    // used to determine if the value for 
    // this SetOnce object has already been set.
    public bool IsSet
    {
      get { return isSet; }
    }
    // return true if this is the initial set, 
    // return false if this is after the initial set.
    // alternatively, you could make it be a void method
    // which would throw an exception upon any invocation after the first.
    public bool SetValue(T value)
    {
       // or you can make thread-safe with a lock..
       if (IsSet)
       {
          return false; // or throw exception.
       }
       else 
       {
          mySetOnceField = value;
          return isSet = true;
       }
    }

    public T GetValue()
    {
      // returns default value of T if not set. 
      // Or, check if not IsSet, throw exception.
      return mySetOnceField;         
    }
} // end SetOnce

public class MyClass 
{
  private SetOnce<int> myReadonlyField = new SetOnce<int>();
  public void DoSomething(int number)
  {
     // say this is where u want to FIRST set ur 'field'...
     // u could check if it's been set before by it's return value (or catching the exception).
     if (myReadOnlyField.SetValue(number))
     {
         // we just now initialized it for the first time...
         // u could use the value: int myNumber = myReadOnlyField.GetValue();
     }
     else
     {
       // field has already been set before...
     }

  } // end DoSomething

} // end MyClass

Answer 2

现在假设我确实想要这个“赋值一次”约束，但我宁愿允许在构造函数之外完成赋值

请注意，延迟初始化很复杂，因此对于所有这些答案，如果您有多个线程，您应该小心尝试访问您的对象。

如果您想在类内部执行此操作，

您可以使用 C# 4.0 内置的延迟初始化功能：

• http://msdn.microsoft.com/en-us/library/dd997286.aspx
• http://msdn.microsoft.com/en-us/library/dd642331.aspx
• http://sankarsan.wordpress.com/2009/10/04/laziness-in-c-4-0-lazyt/

或者对于旧版本的 C#，只需提供 get 方法，并检查您是否已使用支持字段进行初始化：

public string SomeValue
{
    get
    {
        // Note: Not thread safe...
        if(someValue == null)
        {
            someValue = InitializeSomeValue(); // Todo: Implement
        }

        return someValue;
    }
}

如果您想在类之外执行此操作

您想要 Popsicle 不变性：

• http://blogs.msdn.com/b/ericlippert/archive/2007/11/13/immutability-in-c-part-one-kinds-of-immutability.aspx
• < a href="http://msdn.microsoft.com/en-us/library/ms750509.aspx" rel="nofollow">http://msdn.microsoft.com/en-us/library/ms750509.aspx
• http://csharpindepth.com/Talks.aspx（搜索“冰棒不变性”，您会找到一个视频）

基本上：

• 您制作了整个类可写，但添加一个 Freeze 方法。
• 调用此 freeze 方法后，如果用户尝试调用类上的 setter 或 mutator 方法，您将引发 ModifyFrozenObjectException。
• 您可能需要一种方法让外部类确定您的类是否IsFrozen。

顺便说一句，这些名字是我刚刚起的。诚然，我的选择很差，但目前还没有普遍遵循的惯例。

目前，我建议您创建一个 IReezable 接口以及可能的相关异常，这样您就不必依赖于 WPF 实现。像这样的东西：

public interface IFreezable
{
    void Freeze();
    bool IsFrozen { get; }
}

Answer 3

您可以使用 Lazyclass:

private readonly Lazy<Foo> _foo = new Lazy<Foo>(GetFoo);

public Foo Foo
{
    get { return _foo.Value; }
}

private static Foo GetFoo()
{
    // somehow create a Foo...
}

GetFoo 仅在您第一次调用 Foo 属性时才会被调用。

Answer 4

这在埃菲尔铁塔中被称为“一次”功能。这是 C# 中的一个重大疏忽。新的 Lazy 类型是一个很差的替代品，因为它不能与其非惰性版本互换，而是要求您通过其 Value 属性访问包含的值。因此，我很少使用它。噪声是 C# 代码的最大问题之一。理想情况下，人们想要这样的东西......

public once Type PropertyName { get { /* generate and return value */ } }

而不是当前的最佳实践......

Type _PropertyName; //where type is a class or nullable structure
public Type PropertyName
{
    get
    {
        if (_PropertyName == null)
            _PropertyName = /* generate and return value */ 
        return _PropertyName
    }
}