Can objects of structures lie on the heap?

Yes, they can.

Value type objects in C# are usually stored on the stack. However, they can be located on the heap in the following cases:

• They are fields of reference types (classes). The class object is on the heap, and its struct fields will be stored along with it.
• Boxing. When a struct object is converted to an object type or interface, it is wrapped in a reference type and placed on the heap.
• Array elements of structs. An array (which is a reference type) is placed on the heap, and its struct elements are stored in the memory allocated for this array.

Example of boxing:

// Struct object is on the stack
int initialValue = 10;

// Boxing: the struct is wrapped into an object and placed on the heap
object boxedValue = initialValue;

// Casting (unboxing) is necessary to work with the value as an int
int unboxedValue = (int)boxedValue;

Example of a struct as a class field:

// Class object will be on the heap
public class Container
{
    // Struct as a class field - will be stored on the heap along with the Container object
    public Point Coordinates;
}

// Struct definition
public struct Point
{
    public int X;
    public int Y;
}

// Creating a Container class object on the heap
Container c = new Container();

Example of an array of structs:

// Array of Points is a reference type and is placed on the heap
Point[] pointsArray = new Point[5];

// Array elements (Point structs) will be stored on the heap in the memory allocated for the array
pointsArray[0] = new Point { X = 1, Y = 2 };