Почему я не могу использовать виртуальные/переопределенные переменные класса, как я могу использовать методы?

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

В вашем случае вы можете установить prefix в конструкторе наследующего класса:

// Base class field declaration and constructor
protected string prefix;

public Transaction()
{
  prefix = "Primary";
}

// Child class constructor
public SecondaryTransaction()
{
  prefix = "Secondary";
}

Вы также можете создать свойство вместо поля и сделать свойство виртуальным. Это позволит вам изменить поведение геттера и сеттера для свойства в наследующем классе:

// Base class
public virtual string Prefix { get { /* ... */ } set { /* ... */ } }

// Child class
public override string Prefix { get { /* ... */ } set { /* ... */ } }

EDIT: Что касается вашего вопроса об использовании переменной в базовом конструкторе до того, как наследующий класс установил ее, один из способов решить эту проблему — определить метод инициализации в базовом классе, переопределить его в наследующем class и вызовите его из базового конструктора перед доступом к каким-либо полям:

// Base class
public class Base
{
  protected string prefix;

  public Base()
  {
    Initialize();
    Console.WriteLine(prefix);
  }  

  protected virtual void Initialize()
  {
    prefix = "Primary";
  }
}

// Inheriting class
public class Child : Base
{
  public override void Initialize()
  {
    prefix = "Secondary";
  }
}

РЕДАКТИРОВАТЬ 2: вы также спросили, в чем разница между виртуальным/переопределением и сокрытием имени (новое ключевое слово в методах), следует ли его избегать и может ли оно быть полезным.

Сокрытие имен — это функция, которая прерывает наследование в случае сокрытия виртуальных методов. Т.е., если скрыть метод Initialize() в дочернем классе, базовый класс его не увидит и не вызовет. Кроме того, если бы метод Initialize() был общедоступным, внешний код, который вызывал бы Initialize() для ссылки базового типа, вызывал бы Initialize() для базового типа.

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

Статический или невиртуальный метод или свойство — это просто адрес памяти (для упрощения). Виртуальный метод или свойство идентифицируется записью в таблице. Эта таблица зависит от класса, определяющего метод или свойство. Когда вы переопределяете виртуальный член в производном классе, вы фактически изменяете запись в таблице для производного класса, чтобы она указывала на переопределяющий метод. Во время выполнения доступ к такому элементу всегда осуществляется через таблицу. Таким образом, запись может быть переопределена любым производным классом.

Для полей такого механизма нет, поскольку они предназначены для быстрого доступа.

Использование «нового» для члена означает, что вы не хотите переопределять запись в таблице, но вам нужен новый член (с тем же именем, что и у существующего виртуального, плохая практика, если вы спросите меня).

Если вы получаете доступ к виртуальному члену через указатель на базовый класс, вы никогда не получите доступ к члену, определенному как «новый» в производном классе, что является разницей, упомянутой во второй части вашего вопроса.

Скорее создайте свойство для члена префикса - таким образом вы можете установить для свойства виртуальный/абстрактный

Поля используются для хранения состояния объекта, они помогают объекту инкапсулировать данные и скрывать проблемы реализации от других. Имея возможность переопределить поле, мы передаем проблемы реализации класса клиентскому коду (включая подтипы). Из-за этого большинство языков приняли решение, что нельзя определять переменные экземпляра, которые можно переопределить (хотя они могут быть общедоступными/защищенными... так что вы можете получить к ним доступ).

Вы также не можете помещать переменные экземпляра в интерфейс

В вашем примере, если вы не переопределили "Show" в классе SecondaryTransaction, то вызов Show для экземпляра SecondaryTransaction фактически будет вызывать метод в базовом классе (Transaction), который, следовательно, будет использовать "Show" в базе класс, в результате чего выводится:

Primary: name1, state1 
Primary: name1, state1

Таким образом, в зависимости от того, какой метод вы вызываете (т. е. в базовом классе или в дочернем классе), код будет иметь другое значение для «префикса», что будет кошмаром в обслуживании. Я подозреваю, что вы, вероятно, хотите/должны сделать, это показать свойство транзакции, которое обертывает «префикс».

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

Что бы я сделал (если бы я абсолютно не хотел/не мог использовать свойства):

public class Transaction
{
    public string Name { get; set; }
    public string State { get; set; }
    protected string prefix = "Primary";
    public virtual string Show()
    {
        return String.Format("{0}: {1}, {2}", prefix, Name, State);
    }
}
public class SecondaryTransaction : Transaction
{ 
    public SecondaryTransaction()
    {
        prefix = "Secondary";
    }
    public override string Show()
    {
        return String.Format("{0}: {1}, {2}", prefix, Name, State);
    }
}

Изменить: (согласно моему комментарию к другому ответу)

Если вы вызываете ctor вашего базового класса и вам нужно установить значение, вам, вероятно, придется изменить транзакцию, возможно, так:

public class Transaction
{
    public string Name { get; set; }
    public string State { get; set; }
    protected string prefix = "Primary";
    // Declared as virtual ratther than abstract to avoid having to implement "TransactionBase"
    protected virtual void Initialise()
    { }
    public Transaction()
    {
        Initialise();
    }
    public virtual string Show()
    {
        return String.Format("{0}: {1}, {2}", prefix, Name, State);
    }
}
public class SecondaryTransaction : Transaction
{ 
    protected override void Initialise()
    {
        prefix = "Secondary";
    }
    public override string Show()
    {
        return String.Format("{0}: {1}, {2}", prefix, Name, State);
    }
}

Почему вы хотите переопределить защищенную переменную, ведь все, что вам нужно сделать, это установить для нее что-то еще в переопределяющем классе (возможно, в конструкторе)?

Вы не можете, потому что это бесполезно. Чего бы вы добились, переопределив поле?

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

Вы не можете, потому что это бесполезно. Чего бы вы добились, переопределив поле? Простой:

class Animal{

    public class Head {
        int eye = 8;
    } 
    Head head = new Head()
    public void Test() 
    { 
        print head.eye; 
        DoOtherStufs(); 
    } //8

    protected virtual void DoOtherStufs() 
    {}
}

class Cat : Animal{
    class new Head : Animal.Head 
    {
        int mouth;
    } 
    Head head = new Head()
    protected override void DoOtherStufs() 
    { 
        print head.eye; 
    }
} 
Cat cat = new Cat();

cat.head.eye = 9;
print cat.Test() 

Это напечатает 8 9 вместо 9 9, как ожидалось. Мне нужен функционал базового класса, но мне также нужен унаследованный класс, с помощью которого я мог бы манипулировать (увеличивать) vars внутри vars внутренних групповых классов. Это невозможно!!