属性支持值范围

Question

是否有这样的可能？我假设不是，但它看起来不错对我说：

class MyClass { 
    public int Foo { 
     get { return m_foo; } 
     set { 
      // Bounds checking, or other things that prevent the use 
      // of an auto-implemented property 
      m_foo = value; 
     } 

     // Put the backing field actually *in* the scope of the property 
     // so that the rest of the class cannot access it. 
     private int m_foo; 
    } 

    void Method() { 
     m_foo = 42; // Can't touch this! 
    } 
} 

我当然知道这个语法是不正确的，这将无法编译。为了清晰地表达我的想法，这是假想的未来-C＃。我对这个有点假设的问题表示歉意，但对程序员来说太具体了。

类似这样的东西可以在编译器中实现，它可以用于一个目的：只允许属性的get和set访问器查看字段，实质上允许该属性是自包含的（作为自动实现的属性），而允许额外的获取/设置逻辑。

Answer 1

简短的回答是否定的，今天这是不可能在C＃。

我们经常得到这样的功能请求;这是更一般形式的一个很好的功能。更一般的形式是为了更清楚地使寿命的本地可变正交的其范围。

只是为了确保这些条款是明确的：a 变量是一个存储位置，可能命名。每个变量具有寿命：的时间在运行时，其中可变保证指有效的存储量。一个名称的范围是在其中可以使用该名称的文本的区域;这是一个编译时的概念，而不是运行时的概念。一个当地变量是一个变量，其范围是语句块。

在许多语言中，一个局部变量的寿命密切相关的其范围：当控制逻辑进入所述范围在运行时，寿命开始和当它离开范围，寿命结束。这是在C＃中真正有一些明显的警告：

• 本地的寿命可以延长或截断如果运行时能够确定，这样做并没有什么影响，以托管代码当前线程行动上。其他线程（如终结器线程）和当前线程上的非托管代码的操作都是实现定义的。

• 位于迭代器块，异步方法或匿名函数的封闭外部变量中的本地生命周期可以扩展为匹配或超过迭代器，任务，委托或表达式树使用它。

显然这不是一个要求该本地的寿命和范围以任何方式被连接在一起。如果我们可以显式地拥有一个实例或静态字段的生命周期，但本地的范围，那将是很好的。 C有这个功能;你可以创建一个“静态”局部变量。 C＃没有。您的建议基本上是允许在具有实例生命周期但其作用域仅限于该块的属性块中的本地变量。

我想这个功能为“好”的分类。只要您的手臂没有时间执行，我们就会列出潜在的“好”功能列表，因此我不希望这个功能能够在短时间内将它列入列表顶部。感谢您的反馈，但;它有助于我们优先考虑该列表。

Answer 2

不可以，唯一可以在物业主体内的是get和set。

Answer 3

根据C＃4.0语言规范。

但是，与字段不同，属性不表示存储位置。 相反，属性具有访问器，用于指定在读取或写入其值时执行的语句为 。

添加一个字段需要一个内存位置。所以不，这是不可能的。

Answer 4

嗯，这是相当难以对付，可能不是很高性能，而不是我真正使用，但在技术上它是从类的其余部分模糊支持字段的方式。

public class MySuperAwesomeProperty<T> 
{ 
    private T backingField; 
    private Func<T, T> getter; 
    private Func<T, T> setter; 
    public MySuperAwesomeProperty(Func<T, T> getter, Func<T, T> setter) 
    { 
     this.getter = getter; 
     this.setter = setter; 
    } 

    public T Value 
    { 
     get 
     { 
      return getter(backingField); 
     } 
     set 
     { 
      backingField = setter(value); 
     } 
    } 
} 

public class Foo 
{ 
    public MySuperAwesomeProperty<int> Bar { get; private set; } 


    public Foo() 
    { 
     Bar = new MySuperAwesomeProperty<int>(
      value => value, value => { doStuff(); return value; }); 

     Bar.Value = 5; 

     Console.WriteLine(Bar.Value); 
    } 

    private void doStuff() 
    { 
     throw new NotImplementedException(); 
    } 
} 

Answer 5

这里是我采取的是：

public class WrappedField<T> 
{ 
    public class Internals 
    { 
     public T Value; 
    } 

    private readonly Internals _internals = new Internals(); 
    private readonly Func<Internals, T> _get; 
    private readonly Action<Internals, T> _set; 

    public T Value 
    { 
     get { return _get(_internals); } 
     set { _set(_internals, value); } 
    } 

    public WrappedField(Func<Internals, T> get, Action<Internals, T> set) 
    { 
     _get = get; 
     _set = set;    
    } 

    public WrappedField(Func<Internals, T> get, Action<Internals, T> set, T initialValue) 
     : this(get, set) 
    { 
     _set(_internals, initialValue); 
    } 
} 

用法：

class Program 
{ 
    readonly WrappedField<int> _weight = new WrappedField<int>(
     i => i.Value,   // get 
     (i, v) => i.Value = v, // set 
     11);     // initialValue 

    static void Main(string[] args) 
    { 
     Program p = new Program(); 
     p._weight.Value = 10; 

     Console.WriteLine(p._weight.Value); 
    } 
} 

Answer 6

如果你想避免仿制药，你总是可以隐藏_backingField和范围在一个私人的检查内心阶层。您甚至可以通过将外部类设为部分来进一步隐藏它。当然，外部和内部阶层之间必须有一些委派，这是一个无赖。代码解释我的想法：

public partial class MyClass 
{ 
    public int Property 
    { 
     get { return _properties.Property; } 
     set { _properties.Property = value; } 
    } 

    public void Stuff() 
    { 
     // Can't get to _backingField... 
    } 
} 

public partial class MyClass 
{ 
    private readonly Properties _properties = new Properties(); 

    private class Properties 
    { 
     private int _backingField; 

     public int Property 
     { 
      get { return _backingField; } 
      set 
      { 
       // perform checks 
       _backingField = value; 
      } 
     } 
    } 
} 

但是这是很多代码。为了证明所有锅炉板，原来的问题已相当严重......