Обновление и его влияние на кучу

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

Если вы создаете экземпляр Parent, у вас будет родительский объект в памяти. Если вы примените это к любому из дочерних классов, это приведет к ошибке InvalidCastException.

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

Кроме того, если вы создаете экземпляр ChildA, приводите его к Parent, а затем пытаетесь привести к ChildB, вы получите InvalidCastException

"Нормальное" преобразование типов ссылок вверх и вниз

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

Так что нет, нет никаких дополнительных накладных расходов на кучу при приведении ссылочных типов (т.е. экземпляров объектов из классов).

Рассмотрим следующую иерархию классов:

public class Fruit
{
    public Color Colour {get; set;}
    public bool Edible {get; set;}
}

public class Apple : Fruit
{
    public Apple { Color = Green; Edible = true; KeepsDoctorAtBay = true;}
    public bool KeepsDoctorAtBay{get; set;}
}

Что при использовании как с повышением, так и с понижением:

В куче всегда есть только одно выделение, которое является начальным var foo = new Apple().

После различных назначений переменных все три переменные, foo, bar и baz, указывают на один и тот же объект (экземпляр Apple в куче).

Восходящее преобразование (Fruit bar = foo) просто ограничит доступный доступ к переменной только Fruit методами и свойствами, и если (Apple)bar преобразование вниз будет успешным, все методы, свойства и события типа нижнего преобразования будут доступны для переменной. Если приведение вниз завершится неудачно, будет выброшено InvalidCastException, так как система типов проверит совместимость типа объекта кучи с типом переменной во время выполнения.

Операторы преобразования

Согласно комментарию tolanj, все ставки на кучу отключены, если оператор явного преобразования заменяет стандартное приведение ссылочных типов.

Например, если мы добавим несвязанный класс:

public class WaxApple // Not inherited from Fruit or Apple
{
    public static explicit operator Apple(WaxApple wax)
    {
        return new Apple
        {
            Edible = false,
            Colour = Color.Green,
            KeepsDoctorAtBay = false
        };
    }
}

Как вы понимаете, explicit operator Apple от WaxApple может делать все, что захочет, в том числе размещать новые объекты в куче.

var wax = new WaxApple();
var fakeApple = (Apple)wax;
// Explicit cast operator called, new heap allocation as per the conversion code. 

Приведение (вниз) — это не что иное, как представление экземпляра класса "глазами родительского класса". Таким образом, вы не теряете и не добавляете какую-либо информацию или память при приведении, вы просто ссылаетесь на ту же память, которая уже выделена для исходного экземпляра. По этой причине вы все еще можете получить доступ (например, путем отражения) к членам ChildA в переменной типа Parent. Информация все равно есть, ее просто не видно.

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

Однако имейте в виду, что это не применяется, если вы предоставляете свой собственный состав, например. с ChildA по ChildB. Это обычно будет выглядеть более или менее похоже на это:

public static explicit operator ChildA(ChildB b)
{
    var a = new ChildA((Parent)b);
    /* set further properties defined in ChildA but not in ChildB*/
}

Здесь у вас есть два совершенно разных экземпляра, один типа ChildA и один типа ChildB, которые оба потребляют свою собственную память.

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

Нет, потому что класс Parent не знает о своих потомках.

var a = new ClassA();

.NET выделяет память для всех членов ClassA.

var b = (Parent)a;

.NET ничего не делает с памятью. a и b указывают на один и тот же блок памяти (выделенный для ClassA).