Публичная переменная С# как доступная для записи внутри класса, но только для чтения вне класса

Не используйте поле — используйте свойство:

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

В этом примере Foo.Bar доступен для чтения везде и доступен для записи только членам самого Foo.

В качестве примечания: в этом примере используется функция C#, представленная в версии 3, которая называется автоматически реализуемые свойства. Это синтаксический сахар, который компилятор преобразует в обычное свойство с закрытым резервным полем, например:

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;
        }
    }
}

Вы должны использовать свойство для этого. Если у вас все в порядке с автоматической реализацией геттера/сеттера, это будет работать:

public string SomeProperty { get; private set; }

Обратите внимание, что в любом случае вы не должны выставлять поля как общедоступные, за исключением некоторых ограниченных обстоятельств. Вместо этого используйте свойство.

Конечно. Сделайте его свойством и сделайте сеттер закрытым:

public Int32 SomeVariable { get; private set; }

Затем, чтобы установить его (из какого-то метода в классе):

SomeVariable = 5;

Используйте частную переменную и выставляйте общедоступное свойство.

class Person
{
  private string name;

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

Разве вам не разрешено использовать недвижимость для этого? Если ты:

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

Пока ответы работают хорошо, если вы не используете ссылочные типы. В противном случае вы все равно сможете манипулировать внутренностями этой переменной. например:

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; }
        }
    }
}

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;
            }
        }
    }
}

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;
            }
        }
    }
}

Некро точно, но это стоит упомянуть с улучшениями языка в 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;

    }

Определить его как частный? Это то, о чем вы просите, вы можете изменить его в любом месте внутри класса контейнера, но вы не можете выйти за его пределы.