C# 公共变量在类内可写，但在类外只读

Question

我有一个 .Net C# 类，我需要将变量公开。我需要在方法中（而不是在构造函数中）初始化此变量。但是，我不希望其他类可以修改该变量。这可能吗？

Answer 1

不要使用字段 - 使用属性：

class Foo
{
    public string Bar { get; private set; }
}

在此示例中，Foo.Bar 在任何地方都可读，并且只能由 Foo 本身的成员写入。

附带说明一下，此示例使用版本 3 中引入的 C# 功能，称为“自动实现的属性”。这是语法糖，编译器将其转换为具有私有支持字段的常规属性，如下所示：

class Foo
{
    [CompilerGenerated]
    private string <Bar>k__BackingField;

    public string Bar
    {
        [CompilerGenerated]
        get
        {
            return this.<Bar>k__BackingField;
        }
        [CompilerGenerated]
        private set
        {
            this.<Bar>k__BackingField = value;
        }
    }
}

Answer 2

public class Foo
{
  public string Bar { get; private set; } 
}

Answer 3

为此，您必须使用属性。如果您对自动 getter/setter 实现感到满意，那么这将起作用：

public string SomeProperty { get; private set; }

请注意，无论如何您都不应该将字段公开为公共字段，除非在某些有限的情况下。请改用属性。

Answer 4

当然。将其设置为属性，并将 setter 设置为私有：

public Int32 SomeVariable { get; private set; }

然后设置它（从类中的某个方法中）：

SomeVariable = 5;

Answer 5

使用私有变量并公开公共属性。

class Person
{
  private string name;

  public string Name
  {
    get
    {
      return name;
    }
  }
}

Answer 6

您不允许为此使用财产吗？如果您是：

private string _variable
public string Variable {
    get {
        return _variable;
    }
}

Answer 7

只要您不使用引用类型，到目前为止的答案就很好用。否则，您仍然可以操纵该变量的内部结构。
例如：

using System;
namespace Playground
{
    class Program
    {
        static void Main(string[] args)
        {
            var fo = new Fo();
            fo.Init();
            Console.WriteLine(fo.SomeBar.SomeValue);
            fo.SomeBar.SomeValue = "Changed it!";
            Console.WriteLine(fo.SomeBar.SomeValue);
            Console.Read();
        }
        public class Fo
        {
            public Bar SomeBar { get; private set; }
            public void Init()
            {
                SomeBar = new Bar{SomeValue = "Hello World!"};
            }
        }
        public class Bar
        {
            public String SomeValue { get; set; }
        }
    }
}

This will result in the console output:

Hello World!
Changed it!

这可能正是您想要的，因为您无法更改 SomeBar 但如果您想让变量的内部不可修改，您需要传回变量的副本，例如：

using System;
namespace Playground
{
    class Program
    {
        static void Main(string[] args)
        {
            var fo = new Fo();
            fo.Init();
            Console.WriteLine(fo.SomeBar.SomeValue);
            fo.SomeBar.SomeValue = "Changed it!";
            Console.WriteLine(fo.SomeBar.SomeValue);
            Console.Read();
        }
        public class Fo
        {
            private Bar _someHiddenBar;
            public Bar SomeBar => new Bar(_someHiddenBar);
            public void Init()
            {
                _someHiddenBar = new Bar{SomeValue = "Hello World!"};
            }
        }
        public class Bar
        {
            public String SomeValue { get; set; }
            public Bar(){}
            public Bar(Bar previousBar)
            {
                SomeValue = previousBar.SomeValue;
            }
        }
    }
}

which will result in the output:

Hello World!
Hello World!

请参阅评论了解我添加第三个示例的原因：

using System;
namespace Playground
{
    class Program
    {
        static void Main(string[] args)
        {
            var fo = new Fo();
            fo.Init();
            Console.WriteLine(fo.SomeBar.SomeValue);
            //compile error
            fo.SomeBar.SomeValue = "Changed it!";
            Console.WriteLine(fo.SomeBar.SomeValue);
            Console.Read();
        }
        public class Fo
        {
            private Bar _someHiddenBar;
            public Bar SomeBar => new Bar(_someHiddenBar);
            public void Init()
            {
                _someHiddenBar = new Bar("Hello World!");
            }
        }
        public class Bar
        {
            public String SomeValue { get; }
            public Bar(string someValue)
            {
                SomeValue = someValue;
            }
            public Bar(Bar previousBar)
            {
                SomeValue = previousBar.SomeValue;
            }
        }
    }
}

Answer 8

Necro 当然可以，但这还不用说 6.0 中语言的改进

class Foo {

    // The new assignment constructor is wonderful shorthand ensuring
    // that the var is only writable inside the obj's constructor
    public string Bar { get; private set; } = String.Empty;

    }

Answer 9

将其定义为私有？这就是您所要求的，您可以在容器类内的任何位置修改它，但不能在它之外